diskinttest Class Reference

Disk intersection tests. More...

#include <diskinttest.h>

Collaboration diagram for diskinttest:

List of all members.

Public Member Functions
void	test01 (int &argc, char **argv)
	Disk and plane intersection.
void	test02 (int &argc, char **argv)
	Disk and disk intersection.
void	test03 (int &argc, char **argv)
	Cylinder and cylinder intersection.
Static Public Member Functions
static void	display01 ()
	Display handler.
static void	keyboard01 (unsigned char key, int x, int y)
	Keyboard handler for test01.
static void	keyboard02 (unsigned char key, int x, int y)
	Keyboard handler for test02.
static void	keyboard03 (unsigned char key, int x, int y)
	Keyboard handler for test03.
static void	update01 ()
static void	update02 ()
static void	update03 ()
static void	update03lineline ()
Public Attributes
gobjContainer	xGraphics
	Global graphics container.
Static Public Attributes
static disk *	D1ptr
static disk *	D2ptr
static plane *	P1ptr
static gobjMyCircleDraw *	D1cd
static gobjMyCircleDraw *	D2cd
static gobjContainer *	diskintersection
	Holds the intersection graphics for test02.
static cylinder *	C1ptr
static cylinder *	C2ptr
static gobjContainer *	cylinderintersection
static bool	cylinderscollide = false
static gobjgluCylinder *	C1cd
static gobjgluCylinder *	C2cd
static float	transparency = 0.6
static bool *	help = 0
	Toggle the help menu.

---

Detailed Description

Disk intersection tests.

Definition at line 13 of file diskinttest.h.

---

Member Function Documentation

void diskinttest::display01

(

)

[static]

Display handler.

Definition at line 37 of file diskinttest.cpp.

References gobjContainer::draw(), glerrordisplay(), and gobj::global.

Referenced by test01(), test02(), and test03().

{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  gobj::global->draw();

  glerrordisplay();
  
  glutSwapBuffers();
}

void diskinttest::keyboard01	(	unsigned char	key,
		int	x,
		int	y
	)			[static]

Keyboard handler for test01.

Definition at line 48 of file diskinttest.cpp.

References D1ptr, delta, disk::nml, disk::pos, update01(), point3< T >::x, point3< T >::y, and point3< T >::z.

Referenced by test01().

{
  static double delta = 0.1;
  static bool mode=true;

  switch (key)
  {
    case 27:
      exit(0);
      break;
    case 'j': 
      if (mode)
        D1ptr->pos.x += delta; 
      else
        D1ptr->nml.x += delta;
    break;
    case 'J': 
      if (mode)
        D1ptr->pos.x -= delta; 
      else
        D1ptr->nml.x -= delta;
    break;

    case 'k': 
      if (mode)
        D1ptr->pos.y += delta; 
      else
        D1ptr->nml.y += delta;
      break;
    case 'K': 
      if (mode)
        D1ptr->pos.y -= delta; 
      else
        D1ptr->nml.y -= delta; 

      break;

    case 'l': 
      if (mode)
        D1ptr->pos.z += delta; 
      else
        D1ptr->nml.z += delta; 
      break;
    case 'L': 
      if (mode)
        D1ptr->pos.z -= delta; 
      else
        D1ptr->nml.z -= delta; 
      break;
    
    case '+': delta *= 10.0; if (delta==0.0) delta=0.1; break;
    case '-': delta /= 10.0; break;

    case 'm': mode = !mode; break;

    case 'p':
      cout << (stringc)*D1ptr << endl;
      break;
  }

  update01();
  glutPostRedisplay();
}

void diskinttest::keyboard02	(	unsigned char	key,
		int	x,
		int	y
	)			[static]

Keyboard handler for test02.

Definition at line 253 of file diskinttest.cpp.

References D1ptr, D2ptr, delta, help, disk::nml, disk::pos, disk::radius, update02(), point3< T >::x, point3< T >::y, and point3< T >::z.

Referenced by test02().

{
  static double delta = 0.1;
  static bool mode=true;

  switch (key)
  {
    case 27:
      exit(0);
      break;

    case 'j': 
      if (mode)
        D2ptr->pos.x += delta; 
      else
        D2ptr->nml.x += delta;
    break;
    case 'J': 
      if (mode)
        D2ptr->pos.x -= delta; 
      else
        D2ptr->nml.x -= delta;
    break;

    case 'k': 
      if (mode)
        D2ptr->pos.y += delta; 
      else
        D2ptr->nml.y += delta;
      break;
    case 'K': 
      if (mode)
        D2ptr->pos.y -= delta; 
      else
        D2ptr->nml.y -= delta;
      break;

    case 'l': 
      if (mode)
        D2ptr->pos.z += delta; 
      else
        D2ptr->nml.z += delta;
      break;
    case 'L': 
      if (mode)
        D2ptr->pos.z -= delta; 
      else
        D2ptr->nml.z -= delta;
      break;
    
    case '+': delta *= 10.0; if (delta==0.0) delta=0.1; break;
    case '-': delta /= 10.0; break;

    case 'm': mode = !mode; break;

    case 'p':
      cout << (stringc)*D1ptr << endl;
      cout << (stringc)*D2ptr << endl;
      break;

    case 'x': D2ptr->radius += delta; break;
    case 'X': D2ptr->radius -= delta; break;

    case 'h': if (help!=0) *help = !*help; break;
      
  
  }
  update02();
  glutPostRedisplay();
}

void diskinttest::keyboard03	(	unsigned char	key,
		int	x,
		int	y
	)			[static]

Keyboard handler for test03.

Definition at line 479 of file diskinttest.cpp.

References C1ptr, C2ptr, delta, help, cylinder::nml, cylinder::pos, cylinder::radius, transparency, unitbound(), update03(), point3< T >::x, point3< T >::y, and point3< T >::z.

Referenced by test03().

{
  static double delta = 0.1;
  static bool mode=true;

  switch (key)
  {
    case 27:
      exit(0);
      break;

    case 't':
      transparency += delta;
      unitbound(transparency);
      break;
    case 'T':
      transparency -= delta;
      unitbound(transparency);
      break;

    case 'j': 
      if (mode)
        C1ptr->pos.x += delta; 
      else
        C1ptr->nml.x += delta;
    break;
    case 'J': 
      if (mode)
        C1ptr->pos.x -= delta; 
      else
        C1ptr->nml.x -= delta;
    break;
    case 'k': 
      if (mode)
        C1ptr->pos.y += delta; 
      else
        C1ptr->nml.y += delta;
      break;
    case 'K': 
      if (mode)
        C1ptr->pos.y -= delta; 
      else
        C1ptr->nml.y -= delta;
      break;
    case 'l': 
      if (mode)
        C1ptr->pos.z += delta; 
      else
        C1ptr->nml.z += delta;
      break;
    case 'L': 
      if (mode)
        C1ptr->pos.z -= delta; 
      else
        C1ptr->nml.z -= delta;
      break;
    
    case '+': delta *= 10.0; if (delta==0.0) delta=0.1; break;
    case '-': delta /= 10.0; break;

    case 'm': mode = !mode; break;

    case 'p':
      cout << (stringc)*C1ptr << endl;
      cout << (stringc)*C2ptr << endl;
      break;

    case 'x': C1ptr->radius += delta; break;
    case 'X': C1ptr->radius -= delta; break;

    case 'h': if (help!=0) *help = !*help; break;
  }

  update03();
  glutPostRedisplay();
}

void diskinttest::test01	(	int &	argc,
		char **	argv
	)

Disk and plane intersection.

Definition at line 112 of file diskinttest.cpp.

References menusystem::addfont10(), menusystem::addfont12(), menusystem::addnewline(), pointsurface< T, G >::addsurface2D(), D1cd, D1ptr, diskintersection, display01(), gobjpush, keyboard01(), commandline::mapvar(), disk::nml, P1ptr, disk::pos, gobjContainerPrePost::pre, gobjContainer::push(), disk::radius, gobjContainer::set(), zpr::update(), update01(), point3< T >::x, xGraphics, point3< T >::y, and point3< T >::z.

{
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(800,600);
  glutCreateWindow("");
  glutDisplayFunc(display01);
  glutKeyboardFunc(keyboard01);

  OpenGLinitialisation();

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glEnable(GL_NORMALIZE);

  zpr zz;

  xGraphics.set();

  commandline cmd(argc,argv);

  string in;

  cmd.mapvar(in,"in");
  if ( in.empty() )
  {
    cout << "error: in=filename expected" << endl;
    return;
  }

  ifstream filein(in.c_str());
  assert(filein.good()==true);
  if (filein.good()==false)
    return;

  point3<double> nml;
  point3<double> pos;
  double radius;
  double d;

  filein >> nml.x;
  filein >> nml.y;
  filein >> nml.z;
  filein >> pos.x;
  filein >> pos.y;
  filein >> pos.z;
  filein >> radius;

  disk D1(nml,pos,radius);
  D1ptr = & D1;
  

  cout << "disk:  " << (stringc)D1 << endl;

  filein >> nml.x;
  filein >> nml.y;
  filein >> nml.z;
  filein >> d;

  plane P1(nml,d);
  P1ptr = &P1;

  cout << "plane:  " << (stringc)P1 << endl;

  planepointsurface f1(P1);
  pointsurface<> ps1(6000);
  ps1.pre.push(new gobjglColor3ub(184,134,11) );
  ps1.addsurface2D(f1);
  gobjpush(&ps1);

  gobjpush(new gobjglColor3ub(255,255,0));
  gobjMyCircle * cir = new gobjMyCircle();
  gobjMyCircleDraw * cird = 
    new gobjMyCircleDraw(D1.radius,D1.pos,D1.nml,*cir);
  gobjpush(cir);
  gobjpush(cird);

  D1cd = cird;

  diskintersection = new gobjContainer(true);
  gobjpush(diskintersection);

  update01();

  menusystem * menu = 
    new menusystem(0,0,true,point2<GLint>(60,30),20);
  gobjpush(menu);

  menu->addfont12("Disk and Plane Intersection");
  menu->addnewline();
  menu->addnewline();
  menu->addfont10("'j' 'J' x position/normal"); 
  menu->addnewline();
  menu->addfont10("'k' 'K' y position/normal"); 
  menu->addnewline();
  menu->addfont10("'l' 'L' z position/normal"); 
  menu->addnewline();
  menu->addfont10("'m'  Toggle position/normal mode");
  menu->addnewline();
  menu->addfont10("'p'  Print the disk and plane to terminal.");
  menu->addnewline();
  menu->addnewline();
  menu->addfont10("ESC      Quit");

  zz.update();
  glutMainLoop();
}

void diskinttest::test02	(	int &	argc,
		char **	argv
	)

Disk and disk intersection.

Definition at line 325 of file diskinttest.cpp.

References D1cd, D1ptr, D2cd, D2ptr, diskintersection, display01(), gobjpush, help, gobjSwitch< BOOL >::isdrawn, keyboard02(), commandline::mapvar(), disk::nml, point3< T >::normalize(), disk::pos, disk::radius, gobjContainer::set(), zpr::update(), update02(), point3< T >::x, xGraphics, point3< T >::y, and point3< T >::z.

{
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(800,600);
  glutCreateWindow("");
  glutDisplayFunc(display01);
  glutKeyboardFunc(keyboard02);

  OpenGLinitialisation();

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glEnable(GL_NORMALIZE);

  zpr zz;

  xGraphics.set();

  commandline cmd(argc,argv);

  string in;

  cmd.mapvar(in,"in");
  if ( in.empty() )
  {
    cout << "error: in=filename expected" << endl;
    return;
  }

  ifstream filein(in.c_str());
  assert(filein.good()==true);
  if (filein.good()==false)
    return;

  point3<double> nml;
  point3<double> pos;
  double radius;

  filein >> nml.x;
  filein >> nml.y;
  filein >> nml.z;
  filein >> pos.x;
  filein >> pos.y;
  filein >> pos.z;
  filein >> radius;

  nml.normalize();
  disk D1(nml,pos,radius);

  filein >> nml.x;
  filein >> nml.y;
  filein >> nml.z;
  filein >> pos.x;
  filein >> pos.y;
  filein >> pos.z;
  filein >> radius;

  nml.normalize();
  disk D2(nml,pos,radius);

  //gobjpush(new myaxes(1.0));

  gobjpush(new gobjglColor3ub(255,255,0));
  gobjMyCircle * cir = new gobjMyCircle();
  gobjMyCircleDraw * cird = 
    new gobjMyCircleDraw(D1.radius,D1.pos,D1.nml,*cir);
  gobjpush(cir);
  gobjpush(cird);

  D1ptr = &D1;
  D1cd = cird;

  gobjpush(new gobjglColor3ub(153,50,204));
  cird = new gobjMyCircleDraw(D2.radius,D2.pos,D2.nml,*cir);
  gobjpush(cird);

  D2ptr = &D2;
  D2cd = cird;

  diskintersection = new gobjContainer(true);
  gobjpush(diskintersection);


  menusystem * menu = 
    new menusystem(0,0,true,point2<GLint>(60,30),20);

  gobjSwitch<> * menuswitch = new gobjSwitch<>(menu,true);
  help = & menuswitch->isdrawn;
  gobjpush(menuswitch);

  menu->addfont12("Disk and Disk Intersection");
  menu->addnewline();
  menu->addnewline();
  menu->addfont10("'j' 'J' x position/normal"); 
  menu->addnewline();
  menu->addfont10("'k' 'K' y position/normal"); 
  menu->addnewline();
  menu->addfont10("'l' 'L' z position/normal"); 
  menu->addnewline();
  menu->addfont10("'m'  Toggle position/normal mode");
  menu->addnewline();
  menu->addfont10("'p'  Print the two disks to terminal.");
  menu->addnewline();
  menu->addfont10("'x' 'X' Vary disk 2's radius.");
  menu->addnewline();
  menu->addfont10("'h'  Toggle this help menu.");
  menu->addnewline();
  menu->addnewline();
  menu->addfont10("ESC      Quit");


  update02();

  zz.update();
  glutMainLoop();
}

void diskinttest::test03	(	int &	argc,
		char **	argv
	)

Cylinder and cylinder intersection.

Definition at line 746 of file diskinttest.cpp.

References C1cd, C1ptr, C2cd, C2ptr, cylinderintersection, D1cd, D2cd, display01(), gobjpush, cylinder::height, help, gobjSwitch< BOOL >::isdrawn, keyboard03(), commandline::mapvar(), cylinder::nml, cylinder::pos, cylinder::radius, gobjContainer::set(), zpr::update(), update03(), point3< T >::x, xGraphics, point3< T >::y, and point3< T >::z.

{
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(800,600);
  glutCreateWindow("");
  glutDisplayFunc(display01);
  glutKeyboardFunc(keyboard03);

  OpenGLinitialisation();

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glEnable(GL_NORMALIZE);

  zpr zz;

  xGraphics.set();
  gobjpush(new myaxes(1.0));

  commandline cmd(argc,argv);

  string in;
  cmd.mapvar(in,"in");
  if ( in.empty() )
  {
    cout << "error: in=filename expected" << endl;
    return;
  }

  ifstream filein(in.c_str());
  assert(filein.good()==true);
  if (filein.good()==false)
    return;

  point3<double> nml;
  point3<double> pos;
  double radius;
  double height;

  filein >> nml.x;
  filein >> nml.y;
  filein >> nml.z;
  filein >> pos.x;
  filein >> pos.y;
  filein >> pos.z;
  filein >> radius;
  filein >> height;

  cylinder C1(nml,pos,radius,height);

  filein >> nml.x;
  filein >> nml.y;
  filein >> nml.z;
  filein >> pos.x;
  filein >> pos.y;
  filein >> pos.z;
  filein >> radius;
  filein >> height;

  cylinder C2(nml,pos,radius,height);

//cout << (stringc)C1 << endl;
//cout << (stringc)C2 << endl;


  typedef point2<double> pt2;
  typedef point3<double> pt3;


  GLUquadricObj * quad = gluNewQuadric();
  C1cd = new 
    gobjgluCylinder(quad,C1.radius,C1.radius,C1.height,20,20);
  C2cd = new 
    gobjgluCylinder(quad,C2.radius,C2.radius,C2.height,20,20);
  C1ptr = & C1;
  C2ptr = & C2;

  gobjMyCircle * cir = new gobjMyCircle();
  gobjpush(cir);
  gobjMyCircleDraw * cird;
  cird = new gobjMyCircleDraw(C1.radius,C1.pos,C1.nml,*cir);
  gobjpush(cird);
  D1cd = cird;
  cird = new gobjMyCircleDraw(C2.radius,C2.pos,C2.nml,*cir);
  gobjpush(cird);
  D2cd = cird;



  cylinderintersection = new gobjContainer(true);
  gobjpush(cylinderintersection);


  menusystem * menu = 
    new menusystem(0,0,true,point2<GLint>(60,30),20);

  gobjSwitch<> * menuswitch = new gobjSwitch<>(menu,true);
  help = & menuswitch->isdrawn;
  gobjpush(menuswitch);

  menu->addfont12("Cylinder and Cylinder Intersection");
  menu->addnewline();
  menu->addfont12("STATUS:  Not complete - in progress.");
  menu->addnewline();
  menu->addnewline();
  menu->addfont10("'j' 'J' x position/normal"); 
  menu->addnewline();
  menu->addfont10("'k' 'K' y position/normal"); 
  menu->addnewline();
  menu->addfont10("'l' 'L' z position/normal"); 
  menu->addnewline();
  menu->addfont10("'m'  Toggle position/normal mode");
  menu->addnewline();
  menu->addfont10("'p'  Print the two cylinders to terminal.");
  menu->addnewline();
  menu->addfont10("'t'  Adjust the transparency.");
  menu->addnewline();
  menu->addfont10("'h'  Toggle this help menu.");
  menu->addnewline();
  menu->addnewline();
  menu->addfont10("ESC      Quit");


  update03();

  zz.update();
  glutMainLoop();
}

void diskinttest::update01

(

)

[static]

Definition at line 221 of file diskinttest.cpp.

References gobjMyCircleDraw::axis, gobjMyCircleDraw::center, D1cd, D1ptr, diskintersection, disk::intersects(), disk::nml, point3< T >::normalize(), gobjContainer::nuke(), P1ptr, disk::pos, and gobjContainer::push().

Referenced by keyboard01(), and test01().

{
  assert(D1ptr!=0);
  assert(P1ptr!=0);

  D1ptr->nml.normalize();
  D1cd->center = D1ptr->pos;
  D1cd->axis = D1ptr->nml;

  point3<double> p0;
  point3<double> p1;

  diskintersection->nuke();
  if (D1ptr->intersects(p0,p1,*P1ptr))
  {
    diskintersection->push(new gobjglPushAttrib(GL_LIGHTING));
    diskintersection->push(new gobjglPushAttrib(GL_CURRENT_BIT));
    diskintersection->push(new gobjglDisable(GL_LIGHTING));
    diskintersection->push(new gobjglColor3ub(255,0,0));

    diskintersection->push(new gobjglBegin(GL_LINES));
    diskintersection->push(new gobjglVertex3d(p0));
    diskintersection->push(new gobjglVertex3d(p1));
    diskintersection->push(new gobjglEnd());

    diskintersection->push(new gobjglPopAttrib());
    diskintersection->push(new gobjglPopAttrib());
  }


}

void diskinttest::update02

(

)

[static]

Definition at line 443 of file diskinttest.cpp.

References gobjMyCircleDraw::axis, gobjMyCircleDraw::center, D1cd, D1ptr, D2cd, D2ptr, diskintersection, disk::intersects(), disk::nml, point3< T >::normalize(), gobjContainer::nuke(), disk::pos, gobjContainer::push(), disk::radius, and gobjMyCircleDraw::radiusset().

Referenced by keyboard02(), and test02().

{
  assert(D1ptr!=0);
  assert(D2ptr!=0);

  D1ptr->nml.normalize();
  D2ptr->nml.normalize();

  point3<double> p0;
  point3<double> p1;
  diskintersection->nuke();
  if (D1ptr->intersects(p0,p1,*D2ptr))
  {
    diskintersection->push(new gobjglPushAttrib(GL_LIGHTING));
    diskintersection->push(new gobjglPushAttrib(GL_CURRENT_BIT));
    diskintersection->push(new gobjglDisable(GL_LIGHTING));
    diskintersection->push(new gobjglColor3ub(255,0,0));

    diskintersection->push(new gobjglBegin(GL_LINES));
    diskintersection->push(new gobjglVertex3d(p0));
    diskintersection->push(new gobjglVertex3d(p1));
    diskintersection->push(new gobjglEnd());

    diskintersection->push(new gobjglPopAttrib());
    diskintersection->push(new gobjglPopAttrib());
  }

  
  D1cd->axis = D1ptr->nml;
  D2cd->axis = D2ptr->nml;
  D1cd->center = D1ptr->pos;
  D2cd->center = D2ptr->pos;
  D2cd->radiusset(D2ptr->radius);

}

void diskinttest::update03

(

)

[static]

Definition at line 653 of file diskinttest.cpp.

References gobjgluCylinder::baseRadius, C1cd, C1ptr, C2cd, C2ptr, cylinderintersection, cylinderscollide, cylinder::height, gobjgluCylinder::height, gobjContainer::kill(), cylinder::nml, gobjContainer::nuke(), cylinder::pos, gobjContainer::push(), cylinder::radius, radtodeg, gobjgluCylinder::topRadius, transparency, update03lineline(), gobjContainer::vg, point3< T >::x, point3< T >::y, and point3< T >::z.

Referenced by keyboard03(), and test03().

{
  assert(C1ptr!=0);
  assert(C1cd!=0);
  assert(C2ptr!=0);
  assert(C2cd!=0);
  assert(cylinderintersection!=0);



  C1cd->baseRadius = C1ptr->radius;
  C1cd->topRadius = C1ptr->radius;
  C1cd->height = C1ptr->height;

  C2cd->baseRadius = C2ptr->radius;
  C2cd->topRadius = C2ptr->radius;
  C2cd->height = C2ptr->height;

  static uint c1=0;
  static uint c2=0;

  if (c1!=0)
    cylinderintersection->kill(c1);
  if (c2!=0)
    cylinderintersection->kill(c2);

  cylinderintersection->nuke();

  update03lineline();

  cylinderintersection->push(new gobjglEnable(GL_BLEND));
  cylinderintersection->push(
    new gobjglBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) );


  cylinderintersection->push(new gobjglPushMatrix());

  cylinderintersection->push(new gobjglTranslated(C1ptr->pos));

  double th1;
  point3<double> axis;

  angles::rotateaboutaxis(th1,axis,C1ptr->nml);

  th1 *= angles::radtodeg;
  cylinderintersection->push(new gobjglRotated(th1,axis.x,axis.y,axis.z));

  cylinderintersection->push(new myaxes(1.0));
  if (cylinderscollide==false)
    cylinderintersection->push(
      new gobjglColor4f(0.0,0.0,1.0,transparency));
  else
    cylinderintersection->push(
      new gobjglColor4f(1.0,0.0,0.0,transparency));

  cylinderintersection->push(C1cd);
  c1 = cylinderintersection->vg.size()-1;

  cylinderintersection->push(new gobjglPopMatrix());


  cylinderintersection->push(new gobjglPushMatrix());

  cylinderintersection->push(new gobjglTranslated(C2ptr->pos));
  angles::rotateaboutaxis(th1,axis,C2ptr->nml);
  th1 *= angles::radtodeg;
  cylinderintersection->push(new gobjglRotated(th1,axis.x,axis.y,axis.z));

  cylinderintersection->push(new myaxes(1.0));

  if (cylinderscollide==false)
    cylinderintersection->push(
      new gobjglColor4f(0.0,1.0,1.0,transparency));
  else
    cylinderintersection->push(
      new gobjglColor4f(1.0,0.0,0.0,transparency));

  cylinderintersection->push(C2cd);
  c2 = cylinderintersection->vg.size()-1;

  cylinderintersection->push(new gobjglPopMatrix());



  cylinderintersection->push(new gobjglDisable(GL_BLEND));




}

void diskinttest::update03lineline

(

)

[static]

Definition at line 557 of file diskinttest.cpp.

References gobjMyCircleDraw::axis, C1ptr, C2ptr, gobjMyCircleDraw::center, cylinderintersection, cylinderscollide, D1cd, D2cd, cylinder::height, disk::intersects(), line< PT, PD >::lineD3minimized(), disk::nml, line< PT, PD >::nml, cylinder::nml, line< PT, PD >::normalize(), disk::pos, cylinder::pos, gobjContainer::push(), disk::radius, cylinder::radius, gobjMyCircleDraw::radiusset(), and unitbound().

Referenced by update03().

{
  if (C1ptr==0)
    return;
  if (C2ptr==0)
    return;
  if (D1cd==0)
    return;
  if (D2cd==0)
    return;

  if (zero<double>::test(C1ptr->height))
    return;
  if (zero<double>::test(C2ptr->height))
    return;



  
  typedef point3<double> pt3;
  line<pt3,double> L1(C1ptr->nml,C1ptr->pos);
  L1.normalize(C1ptr->height);
  line<pt3,double> L2(C2ptr->nml,C2ptr->pos);
  L2.normalize(C2ptr->height);

  double t1;
  double t2;
  bool res;
  res = L1.lineD3minimized(t1,t2,L2);

  if (res==false)
    return;

  unitbound(t1);
  unitbound(t2);

  disk D1(L1.nml,L1(t1),C1ptr->radius);
  disk D2(L2.nml,L2(t2),C2ptr->radius);

  D1cd->center = D1.pos;
  D1cd->axis = D1.nml;
  D1cd->radiusset(D1.radius);
  D2cd->center = D2.pos;
  D2cd->axis = D2.nml;
  D2cd->radiusset(D2.radius);


  // Infinite cylinders intersection case only.
  point3<double> p0;
  point3<double> p1;
  cylinderscollide = D1.intersects(p0,p1,D2);


  cylinderintersection->push(new gobjglPushAttrib(GL_LIGHTING));
  cylinderintersection->push(new gobjglPushAttrib(GL_CURRENT_BIT));

  cylinderintersection->push(new gobjglDisable(GL_LIGHTING) );

  cylinderintersection->push(new gobjglBegin(GL_LINES));

  // Write the minimal line.
  //cylinderintersection->push(
  //  new gobjglColor4ub(127,255,212,(GLubyte)(floor(transparency*256))));
  cylinderintersection->push( new gobjglColor3ub(127,255,212));
  cylinderintersection->push(new gobjglVertex3d(L1(t1)));
  cylinderintersection->push(new gobjglVertex3d(L2(t2)));


  // Write cylinder1's axis.
  //cylinderintersection->push(
  //  new gobjglColor4ub(255,20,147,(GLubyte)(floor(transparency*256))));
  cylinderintersection->push( new gobjglColor3ub(255,20,147));
  cylinderintersection->push(new gobjglVertex3d(L1(0.0)));
  cylinderintersection->push(new gobjglVertex3d(L1(1.0)));

  // Write cylinder2's axis.
  //cylinderintersection->push(
  //  new gobjglColor4ub(255,140,0,(GLubyte)(floor(transparency*256))));
  cylinderintersection->push( new gobjglColor3ub(255,140,0));
  cylinderintersection->push(new gobjglVertex3d(L2(0.0)));
  cylinderintersection->push(new gobjglVertex3d(L2(1.0)));

  cylinderintersection->push(new gobjglEnd());

  cylinderintersection->push(new gobjglPopAttrib());
  cylinderintersection->push(new gobjglPopAttrib());







}

---

Member Data Documentation

gobjgluCylinder * diskinttest::C1cd [static]

Definition at line 53 of file diskinttest.h.

Referenced by test03(), and update03().

cylinder * diskinttest::C1ptr [static]

Definition at line 47 of file diskinttest.h.

Referenced by keyboard03(), test03(), update03(), and update03lineline().

gobjgluCylinder * diskinttest::C2cd [static]

Definition at line 54 of file diskinttest.h.

Referenced by test03(), and update03().

cylinder * diskinttest::C2ptr [static]

Definition at line 48 of file diskinttest.h.

Referenced by keyboard03(), test03(), update03(), and update03lineline().

gobjContainer * diskinttest::cylinderintersection [static]

Definition at line 50 of file diskinttest.h.

Referenced by test03(), update03(), and update03lineline().

bool diskinttest::cylinderscollide = false [static]

Definition at line 51 of file diskinttest.h.

Referenced by update03(), and update03lineline().

gobjMyCircleDraw * diskinttest::D1cd [static]

Definition at line 41 of file diskinttest.h.

Referenced by test01(), test02(), test03(), update01(), update02(), and update03lineline().

disk * diskinttest::D1ptr [static]

Definition at line 38 of file diskinttest.h.

Referenced by keyboard01(), keyboard02(), test01(), test02(), update01(), and update02().

gobjMyCircleDraw * diskinttest::D2cd [static]

Definition at line 42 of file diskinttest.h.

Referenced by test02(), test03(), update02(), and update03lineline().

disk * diskinttest::D2ptr [static]

Definition at line 39 of file diskinttest.h.

Referenced by keyboard02(), test02(), and update02().

gobjContainer * diskinttest::diskintersection [static]

Holds the intersection graphics for test02.

Definition at line 45 of file diskinttest.h.

Referenced by test01(), test02(), update01(), and update02().

bool * diskinttest::help = 0 [static]

Toggle the help menu.

Definition at line 60 of file diskinttest.h.

Referenced by keyboard02(), keyboard03(), test02(), and test03().

plane * diskinttest::P1ptr [static]

Definition at line 40 of file diskinttest.h.

Referenced by test01(), and update01().

float diskinttest::transparency = 0.6 [static]

Definition at line 57 of file diskinttest.h.

Referenced by keyboard03(), and update03().

gobjContainer diskinttest::xGraphics

Global graphics container.

Definition at line 18 of file diskinttest.h.

Referenced by test01(), test02(), and test03().

---

The documentation for this class was generated from the following files:

• intersectiontests/diskinttest.h
• intersectiontests/diskinttest.cpp