Example #1
0
/*===========================================*/
int VF_BackFaceCullViewPoint(ViewPort *view, Poly *poly_j)
{
  int    n;
  Vector *normal_i, *normal_j, r;

  normal_i = &(view->view_normal);
  normal_j = &(poly_j->normal);
  for (n=0; n<poly_j->np; n++) {
    V3_Sub(&(poly_j->p[n]), &(view->view_point), &r);
    if ((V3_Dot(&r, normal_i)>0.0) && (-V3_Dot(&r, normal_j)>0.0)) return 0;
  }
  return 1;
}
Example #2
0
/*====================================*/
int VF_RayIntersect(Ray *ray, double tmax, Poly *poly)
{
  double t, n_dot_d;
  Vector q;   
    
  n_dot_d = V3_Dot(&(poly->normal), &ray->D);
  if (fabs(n_dot_d)<VF_RAY_TEST) return 0;
  V3_Sub(&(poly->p[0]), &ray->O, &q);
  t = V3_Dot(&(poly->normal), &q)/n_dot_d;
  if (t<=0.0 || t>=tmax) return 0;
  if (poly->np!=2) {
    return (VF_InsidePoly(ray, t, poly));
  } else {
    return (VF_InsideLine(ray, t, poly));
  }
}
Example #3
0
/*===========================================*/
int VF_BackFaceCullPolys(Poly *poly_i, Poly *poly_j)
{
  int    n, m;
  double tmp;
  Vector *normal_i, *normal_j, r;

  normal_i = &(poly_i->normal);
  normal_j = &(poly_j->normal);
  for (m=0; m<poly_i->np; m++) {
    for (n=0; n<poly_j->np; n++) {
      V3_Sub(&(poly_j->p[n]), &(poly_i->p[m]), &r);
      V3_Normalize(&r,tmp);
      if ((V3_Dot(&r, normal_i)>0.0) && (-V3_Dot(&r, normal_j)>0.0)) return 0;
    }
  }
  return 1;
}
Example #4
0
/*=========================================*/
int VF_BehindPlane(Plane *plane, Poly *poly)
{
  int    n;
  double value, spatial_tol;
  VFtopology *topology=VF_CurrentTopology();

  spatial_tol = topology->spatial_tol;
  for (n=0; n<poly->np; n++) {
    value = V3_Dot(&(poly->p[n]), &(plane->normal)) + plane->d;
    if (value > spatial_tol) return 0;
  }
  return 1;
}
Example #5
0
/*=========================================*/
int VF_BehindViewPoint(ViewPort *view, Poly *poly)
{
  int    n;
  double value, spatial_tol;
  VFtopology *topology=VF_CurrentTopology();

  spatial_tol = topology->spatial_tol;
  for (n=0; n<poly->np; n++) {
    value = V3_Dot(&(poly->p[n]), &(view->view_normal)) + view->d;
    if (value > spatial_tol) return 0;
  }
  return 1;
}
Example #6
0
/*=========================================*/
int VF_BehindAndBackFaceCullViewPoint(ViewPort *view, Poly *poly)
{
  int    n;
  double value, spatial_tol;
  Vector *normal_i, *normal_j, r;
  VFtopology *topology=VF_CurrentTopology();

  spatial_tol = topology->spatial_tol;
  for (n=0; n<poly->np; n++) {
    value = V3_Dot(&(poly->p[n]), &(view->view_normal)) + view->d;
    if (value > spatial_tol) {
      /*===========================================*/
      /* THIS VERTEX IS IN FRONT OF THE VIEWPOINT, */
      /* NOW CHECK IF IT IS ALSO FACING IT         */
      /*===========================================*/
      normal_i = &(view->view_normal);
      normal_j = &(poly->normal);
      V3_Sub(&(poly->p[n]), &(view->view_point), &r);
      if ((V3_Dot(&r, normal_i)>0.0) && (-V3_Dot(&r, normal_j)>0.0)) return 0;
      break;
    }
  }
  return 1;
}
Example #7
0
static int
NearestConstraintAxis (HVect  loose,
                       HVect *axes,
                       int    nAxes)
{
  HVect onPlane;
  register double max, dot;
  register int i, nearest;
  max = -1; nearest = 0;

  for (i=0; i<nAxes; i++)
    {
      onPlane = ConstrainToAxis(loose, axes[i]);
      dot = V3_Dot(onPlane, loose);
      if (dot>max)
        {
          max = dot; nearest = i;
        }
    }
  return (nearest);
}
Example #8
0
static HVect
ConstrainToAxis (HVect loose,
                 HVect axis)
{
  HVect onPlane;
  register double norm;

  onPlane = V3_Sub(loose, V3_Scale(axis, V3_Dot(axis, loose)));
  norm = V3_Norm(onPlane);
  if (norm > 0.0)
    {
      if (onPlane.z < 0.0) onPlane = V3_Negate(onPlane);
      return ( V3_Scale(onPlane, 1/sqrt(norm)) );
    }
  /* else drop through */
  /* ================= */

  if (axis.z == 1) onPlane = V3_(1.0, 0.0, 0.0);
  else             onPlane = V3_Unit(V3_(-axis.y, axis.x, 0.0));
  return (onPlane);
}
Example #9
0
double VF_Visibility(Poly *poly_i, Poly *poly_j, 
                     CandidateList *candidates, int nc)
{
  int    i, j, n, ns, cnt, nt, test_vertices=0;
  double tmax, tmp, n_dot_d;
  Ray    ray0,*ray;
  Point  samples_i[4096], samples_j[4096];
  Vector q;
  Adaptive    *adaptive;
  VFenclosure *enclosure=VF_CurrentEnclosure();

  adaptive = &(enclosure->adaptive);
  if (nc==0) return(1.0);
  VF_SamplesUVtoXYZ(poly_i, &(adaptive->visibility.sampling), 
                    adaptive->visibility.sampleuv_i, samples_i);
  VF_SamplesUVtoXYZ(poly_j, &(adaptive->visibility.sampling), 
                    adaptive->visibility.sampleuv_j, samples_j);
  ns = adaptive->visibility.sampling.n;
  if (test_vertices) {
    cnt = nt = ns+poly_i->np*poly_j->np;
  } else {
    cnt = nt = ns;
  }
  /*=================================================*/
  /* TEST VISIBILITY OF RAYS BETWEEN SAMPLING POINTS */
  /*=================================================*/
  for (n=0; n<ns; n++) {
    ray      = &(adaptive->visibility.ray[n]);
    ray->O   = samples_i[n];
    ray->vis = 0;
    V3_Sub(&(samples_j[n]), &(ray->O), &(ray->D));
    V3_Normalize(&(ray->D),tmp);
    n_dot_d = V3_Dot(&(poly_j->normal), &(ray->D));
    if (fabs(n_dot_d)<VF_RAY_TEST) {
      cnt--;
    } else {
      V3_Sub(&(poly_j->p[0]), &(ray->O), &q);
      tmax = V3_Dot(&(poly_j->normal), &q)/n_dot_d;
      if (VF_RayPatchListTest(&(adaptive->visibility.ray[n]), 
                              n, tmax, candidates, nc)) cnt--;
    }
  }
  if (test_vertices) {
    /*===============================================================*/
    /* ALSO TEST RAYS BETWEEN ALL VERTEX COMBINATIONS FOR VISIBILITY */
    /*===============================================================*/
    for (i=0; i<poly_i->np; i++) {
      for (j=0; j<poly_j->np; j++) {
        ray0.vis = 0;
        ray0.O   = poly_i->p[i];
        V3_Sub(&(poly_j->p[j]), &(ray0.O), &(ray0.D));
        V3_Normalize(&(ray0.D),tmp);
        n_dot_d = V3_Dot(&(poly_j->normal), &(ray0.D));
        if (fabs(n_dot_d)<VF_RAY_TEST) {
          cnt--;
        } else {
          V3_Sub(&(poly_j->p[0]), &(ray0.O), &q);
          tmax = V3_Dot(&(poly_j->normal), &q)/n_dot_d;
          if (VF_RayPatchListTest(&ray0, n, tmax, candidates, nc)) {
            cnt--;
          }
        }
      }
    }
  }
  return ((double)(cnt)/(double)(nt));
}
Example #10
0
void OBJECT::SortVertexEdges()
{
    for (int x=0; x<VertexNum; x++)
    {
        if (VertexList[x].EdgeNum>2)
        {
            VECTOR3 vertvector;
            VECTOR3 normal = V3_Normalize(VertexList[x].Normal);
            VECTOR3 vx = VertexList[x].Position;

            float *szogek = new float[VertexList[x].EdgeNum];

            int e=GetEdgeVertex(this,x,VertexList[x].EdgeList[0]);
            VECTOR3 refvector=VertexList[e].Position;
            refvector = V3_Sub(refvector,vx);

            VECTOR3 projvec=normal;
            projvec=V3_Mults(projvec,V3_Dot(refvector,normal));
            refvector = V3_Normalize(V3_Sub(refvector,projvec));

            int y;
            for (y=1; y<VertexList[x].EdgeNum; y++)
            {
                e=GetEdgeVertex(this,x,VertexList[x].EdgeList[y]);
                vertvector = V3_Sub(VertexList[e].Position,vx);
                projvec=V3_Mults(normal,V3_Dot(vertvector,normal));
                vertvector = V3_Normalize(V3_Sub(vertvector,projvec));

                float cosTheta = max(-1.0f,min(1.0f,V3_Dot(vertvector,refvector)));
                float angle = (float)acos(cosTheta) * 180.0f / 3.1415f;

                VECTOR3 crossProd=V3_Cross(vertvector,refvector);
                if (V3_Dot(crossProd,normal) < 0) angle = 360 - angle;

                szogek[y]=angle;

            }

            int smallest,b1;
            float smallestvalue, b2;

            for (int z=0; z<VertexList[x].EdgeNum; z++)
            {
                smallest=z;
                smallestvalue=szogek[z];

                for (y=z; y<VertexList[x].EdgeNum; y++)
                {
                    if (szogek[y]<=smallestvalue)
                    {
                        smallest=y;
                        smallestvalue=szogek[y];
                    }
                }

                b2=szogek[smallest];
                szogek[smallest]=szogek[z];
                szogek[z]=b2;

                b1=VertexList[x].EdgeList[smallest];
                VertexList[x].EdgeList[smallest]=VertexList[x].EdgeList[z];
                VertexList[x].EdgeList[z]=b1;
            }

            delete[] szogek;
        }
    }
}