void drawCylinder(const Vector3& h,Real r,int steps)
{
int i;
float inc = Two*Pi/steps;
Real height=h.norm();
Vector3 hdir=h/height;
Vector3 xb,yb;
GetCanonicalBasis(hdir,xb,yb);
Complex x,dx;
dx.setPolar(1,inc);
Vector3 point,point2;
Vector3 n,n2;
//base
glBegin(GL_TRIANGLE_FAN);
glNormal3v(-hdir);
glVertex3f(0,0,0);
x.set(r,0);
for(i=0; i<=steps; i++) {
point = xb*(-x.x) + yb*x.y;
glVertex3v(point);
x = x*dx;
}
glEnd();
//cap
glBegin(GL_TRIANGLE_FAN);
glNormal3v(hdir);
glVertex3v(h);
x.set(r,0);
for(i=0; i<=steps; i++) {
point = xb*(x.x) + yb*(-x.y) + h;
glVertex3v(point);
x = x*dx;
}
glEnd();
//sides
glBegin(GL_TRIANGLE_STRIP);
dx.setPolar(1,-inc);
x.set(r,0);
for(i=0; i<=steps; i++) {
point = xb*x.x + yb*x.y;
n = (-x.y*xb + x.x*yb);
n.inplaceNormalize();
glNormal3v(n);
glVertex3v(point);
glNormal3v(n);
glVertex3v(point+h);
x = x*dx;
}
glEnd();
}
void drawCone(const Vector3& h, float r, int steps)
{
int i;
float inc = fTwoPi/steps;
Real height=h.norm();
Vector3 hdir=h/height;
Vector3 xb,yb;
GetCanonicalBasis(hdir,xb,yb);
Complex x,dx;
dx.setPolar(1,inc);
Vector3 point,point2;
Vector3 n,n2;
//base
glBegin(GL_TRIANGLE_FAN);
glNormal3v(-hdir);
glVertex3f(0,0,0);
x.set(r,0);
for(i=0; i<=steps; i++)
{
point = xb*(-x.x) + yb*x.y;
glVertex3v(point);
x = x*dx;
}
glEnd();
//sides
glBegin(GL_TRIANGLES);
x.set(r,0);
for(i=0; i<steps; i++)
{
point = xb*x.x + yb*x.y;
n = (-x.y*xb + x.x*yb)/r*height + r*hdir;
n.inplaceNormalize();
x = x*dx;
point2 = xb*x.x + yb*x.y;
n2 = (-x.y*xb + x.x*yb)/r*height + r*hdir;
n2.inplaceNormalize();
glNormal3v(hdir);
glVertex3v(h);
glNormal3v(n);
glVertex3v(point);
glNormal3v(n2);
glVertex3v(point2);
}
glEnd();
}
void Gl1_PFacet::go(const shared_ptr<Shape>& cm, const shared_ptr<State>& st,bool wire2,const GLViewInfo&)
{
PFacet* Pfacet = static_cast<PFacet*>(cm.get());
vector<Vector3r> vertices;
vertices.push_back(Pfacet->node1->state->pos);
vertices.push_back(Pfacet->node2->state->pos);
vertices.push_back(Pfacet->node3->state->pos);
Vector3r pos=Pfacet->node1->state->pos;
st->ori = Quaternionr::Identity();// Otherwise clumped connexions get rotated by the clump motion and the view is messed up (note that orientation is never used in mechanical calculations in the case of connexions and pfacets).
vertices[0]=vertices[0]-pos;
vertices[1]=vertices[1]-pos;
vertices[2]=vertices[2]-pos;
vector<Vector3r> verticesF1 = vertices;
Vector3r normal=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]); normal.normalize();
verticesF1[0]=vertices[0] + normal*Pfacet->radius;
verticesF1[1]=vertices[1] + normal*Pfacet->radius;
verticesF1[2]=vertices[2] + normal*Pfacet->radius;
vector<Vector3r> verticesF2 = vertices;
verticesF2[0] = vertices[0] - normal*Pfacet->radius;
verticesF2[1] = vertices[1] - normal*Pfacet->radius;
verticesF2[2] = vertices[2] - normal*Pfacet->radius;
if(!wire2||!wire){
glDisable(GL_CULL_FACE);
glColor3v(cm->color);
glBegin(GL_TRIANGLES);
glNormal3v(normal); // this makes every triangle different WRT the light direction; important!
glVertex3v(verticesF1[0]);
glVertex3v(verticesF1[1]);
glVertex3v(verticesF1[2]);
glEnd();
glBegin(GL_TRIANGLES);
glNormal3v(Pfacet->normal); // this makes every triangle different WRT the light direction; important!
glVertex3v(verticesF2[2]);
glVertex3v(verticesF2[1]);
glVertex3v(verticesF2[0]);
glEnd();
}
}
void drawTriangle(const Vector3& a,const Vector3& b,const Vector3& c)
{
glBegin(GL_TRIANGLES);
glNormal3v(Triangle3D::normal(a,b,c));
glVertex3v(a);
glVertex3v(b);
glVertex3v(c);
glEnd();
}
void Gl1_Sphere::subdivideTriangle(Vector3r& v1,Vector3r& v2,Vector3r& v3, int depth){
Vector3r v;
//Change color only at the appropriate level, i.e. 8 times in total, since we draw 8 mono-color sectors one after another
if (depth==int(quality) || quality<=0){
v = (v1+v2+v3)/3.0;
GLfloat matEmit[4];
if (v[1]*v[0]*v[2]>0){
matEmit[0] = 0.3;
matEmit[1] = 0.3;
matEmit[2] = 0.3;
matEmit[3] = 1.f;
}else{
matEmit[0] = 0.15;
matEmit[1] = 0.15;
matEmit[2] = 0.15;
matEmit[3] = 0.2;
}
glMaterialfv(GL_FRONT, GL_EMISSION, matEmit);
}
if (depth==1){//Then display 4 triangles
Vector3r v12 = v1+v2;
Vector3r v23 = v2+v3;
Vector3r v31 = v3+v1;
v12.normalize();
v23.normalize();
v31.normalize();
//Use TRIANGLE_STRIP for faster display of adjacent facets
glBegin(GL_TRIANGLE_STRIP);
glNormal3v(v1); glVertex3v(v1);
glNormal3v(v31); glVertex3v(v31);
glNormal3v(v12); glVertex3v(v12);
glNormal3v(v23); glVertex3v(v23);
glNormal3v(v2); glVertex3v(v2);
glEnd();
//terminate with this triangle left behind
glBegin(GL_TRIANGLES);
glNormal3v(v3); glVertex3v(v3);
glNormal3v(v23); glVertex3v(v23);
glNormal3v(v31); glVertex3v(v31);
glEnd();
return;
}
Vector3r v12 = v1+v2;
Vector3r v23 = v2+v3;
Vector3r v31 = v3+v1;
v12.normalize();
v23.normalize();
v31.normalize();
subdivideTriangle(v1,v12,v31,depth-1);
subdivideTriangle(v2,v23,v12,depth-1);
subdivideTriangle(v3,v31,v23,depth-1);
subdivideTriangle(v12,v23,v31,depth-1);
}
void drawQuad(const Vector3& a,const Vector3& b,const Vector3& c,const Vector3& d)
{
glBegin(GL_TRIANGLE_FAN);
glNormal3v(Triangle3D::normal(a,b,c));
glVertex3v(a);
glVertex3v(b);
glVertex3v(c);
glVertex3v(d);
glEnd();
}
template< typename Type > inline void glOneFace(Type & t, unsigned int a, unsigned int b, unsigned int c) {
const Vector3r center = (t->v[0]+t->v[1]+t->v[2]+t->v[3])*.25;
Vector3r n=(t->v[b]-t->v[a]).cross(t->v[c]-t->v[a]);
n.normalize();
const Vector3r faceCenter=(t->v[a]+t->v[b]+t->v[c])/3.;
if((faceCenter-center).dot(n)<0) n=-n;
glNormal3v(n);
glVertex3v(t->v[a]);
glVertex3v(t->v[b]);
glVertex3v(t->v[c]);
}
void Gl1_Facet::go(const shared_ptr<Shape>& cm, const shared_ptr<State>& ,bool wire,const GLViewInfo&)
{
Facet* facet = static_cast<Facet*>(cm.get());
const vector<Vector3r>& vertices = facet->vertices;
const Vector3r* ne = facet->ne;
const Real& icr = facet->icr;
if(cm->wire || wire){
// facet
glBegin(GL_LINE_LOOP);
glColor3v(normals ? Vector3r(1,0,0): cm->color);
glVertex3v(vertices[0]);
glVertex3v(vertices[1]);
glVertex3v(vertices[2]);
glEnd();
if(!normals) return;
// facet's normal
glBegin(GL_LINES);
glColor3(0.0,0.0,1.0);
glVertex3(0.0,0.0,0.0);
glVertex3v(facet->normal);
glEnd();
// normal of edges
glColor3(0.0,0.0,1.0);
glBegin(GL_LINES);
glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[0]));
glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[1]));
glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[2]));
glEnd();
} else {
glDisable(GL_CULL_FACE);
Vector3r normal=(facet->vertices[1]-facet->vertices[0]).cross(facet->vertices[2]-facet->vertices[1]); normal.normalize();
glColor3v(cm->color);
glBegin(GL_TRIANGLES);
glNormal3v(normal); // this makes every triangle different WRT the light direction; important!
glVertex3v(facet->vertices[0]);
glVertex3v(facet->vertices[1]);
glVertex3v(facet->vertices[2]);
glEnd();
}
}
void drawgeom(const GeometricPrimitive3D& geom)
{
switch(geom.type) {
case GeometricPrimitive3D::Point:
{
glBegin(GL_POINTS);
glVertex3v(*AnyCast<Vector3>(&geom.data));
glEnd();
}
break;
case GeometricPrimitive3D::Segment:
{
const Segment3D* seg=AnyCast<Segment3D>(&geom.data);
glBegin(GL_LINES);
glVertex3v(seg->a);
glVertex3v(seg->b);
glEnd();
}
break;
/*
case GeometricPrimitive3D::Circle:
{
const Circle3D* circle = AnyCast<Circle3D>(&geom.data);
glPushMatrix();
glTranslate(circle->center);
drawCircle(circle->axis,circle->radius);
glPopMatrix();
}
break;
*/
/*
case GeometricPrimitive3D::AABB:
{
const AABB3D* aabb=AnyCast<AABB3D>(&geom.data);
drawBoundingBox(aabb->bmin,aabb->bmax);
}
break;
*/
case GeometricPrimitive3D::Box:
{
const Box3D* box=AnyCast<Box3D>(&geom.data);
Matrix4 m;
box->getBasis(m);
glPushMatrix();
glMultMatrix(m);
drawBoxCorner(box->dims.x,box->dims.y,box->dims.z);
glPopMatrix();
break;
}
case GeometricPrimitive3D::Triangle:
{
const Triangle3D* tri=AnyCast<Triangle3D>(&geom.data);
drawTriangle(tri->a,tri->b,tri->c);
break;
}
case GeometricPrimitive3D::Polygon:
{
const Polygon3D* p=AnyCast<Polygon3D>(&geom.data);
Plane3D plane;
p->getPlane(0,plane);
glNormal3v(plane.normal);
glBegin(GL_TRIANGLE_FAN);
glVertex3v(p->vertices[0]);
for(size_t i=1;i+1<p->vertices.size();i++) {
glVertex3v(p->vertices[i]);
glVertex3v(p->vertices[i+1]);
}
glEnd();
break;
}
case GeometricPrimitive3D::Sphere:
{
const Sphere3D* s=AnyCast<Sphere3D>(&geom.data);
glPushMatrix();
glTranslate(s->center);
drawSphere(s->radius,32,32);
glPopMatrix();
break;
}
case GeometricPrimitive3D::Cylinder:
{
const Cylinder3D* s=AnyCast<Cylinder3D>(&geom.data);
glPushMatrix();
glTranslate(s->center);
drawCylinder(s->axis*s->height,s->radius,32);
glPopMatrix();
break;
}
break;
default:
fprintf(stderr,"draw: Unsupported geometry type\n");
return;
}
}
inline void glNormal( const QVector3D & v ) { glNormal3v( reinterpret_cast<const float*>(&v) ); }
