Пример #1
0
void MlUVView::clientDraw()
{
	if(m_texId > -1) {
		glPushMatrix();
		glScalef(32.f, 32.f, 1.f);
		glTranslatef(0.f, 0.f, -10.f);
		getDrawer()->texture(m_texId);
		glPopMatrix();
	}
	
	if(!FeatherLibrary) return;
	MlFeather *f;
	for(f = FeatherLibrary->firstFeatherExample(); FeatherLibrary->hasFeatherExample(); f = FeatherLibrary->nextFeatherExample()) {
		if(!f) continue;
		drawFeather(f);
	}
	
	f = FeatherLibrary->selectedFeatherExample();
	if(!f) return;
	getDrawer()->boundingRectangle(f->getBoundingRectangle());
	
	if(interactMode() == ToolContext::MoveVertexInUV) {
		drawControlVectors(f);
		if(m_selectedVert) {
			Vector3F pv(m_selectVertWP);
			getDrawer()->cube(pv, 0.1f);
		}
	}
}
Пример #2
0
//! [7]
void Base3DView::paintGL()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
    glLoadIdentity();

    float m[16];
	getCamera()->getMatrix(m);
	glMultMatrixf(m);
	
	getDrawer()->m_markerProfile.apply();
	getDrawer()->coordsys(20.f);
	getDrawer()->setAlignDir(getCamera()->eyeDirection());
	clientDraw();
	if(m_isFocused) {
		Vector3F corners[4];
		getCamera()->frameCorners(corners[0], corners[1], corners[2], corners[3]);
		glColor3f(0.f, 0.f, 1.f);
		glBegin(GL_LINE_LOOP);
		glVertex3f(corners[0].x, corners[0].y, corners[0].z);
		glVertex3f(corners[1].x, corners[1].y, corners[1].z);
		glVertex3f(corners[2].x, corners[2].y, corners[2].z);
		glVertex3f(corners[3].x, corners[3].y, corners[3].z);
		glEnd();
	}
	glFlush();
}
Пример #3
0
void Base3DView::drawIntersection() const
{
    IntersectionContext * ctx = getIntersectionContext();
    if(!ctx->m_success) return;
    
    getDrawer()->circleAt(ctx->m_hitP, ctx->m_hitN);
	getDrawer()->boundingBox(ctx->m_bbox);
    getDrawer()->arrow(ctx->m_hitP, ctx->m_hitP + ctx->m_hitN);
}
void ParticleSystemCore::adjustVolume(Volume & volume)
{
    //The adjusted volume is dependent on the Particle System as well as the 
    //Particle Drawer
	Inherited::adjustVolume(volume);

    if(getDrawer() != NULL && getSystem() != NULL)
    {
        getDrawer()->adjustVolume(getSystem(), volume);
    }
}
Пример #5
0
void Base3DView::showBrush() const
{
	getDrawer()->colorAsReference();
	getDrawer()->circleAt(brush()->getSpace(), brush()->getRadius());
	
	if(m_brush->dropoff() > 0.f)
		getDrawer()->circleAt(brush()->getSpace(), brush()->getRadius() * (1.f - m_brush->dropoff()));

    if(brush()->length() > 10e-3)
        getDrawer()->arrow(brush()->heelPosition(), brush()->toePosition());
}
Пример #6
0
void GLWidget::clientDraw()
{
	//_subdiv->draw();
	getDrawer()->edge(_model);
	
	drawBezier();
}
Пример #7
0
void GLWidget::drawMesh()
{
	CudaLinearBvh * bvh = m_mesh->bvh();
	Aabb ab = bvh->bound();
	if(ab.low.x < -1e8 || ab.low.x > 1e8) std::cout<<" invalid big box "<<aabb_str(ab);
	
#ifdef BVHSOLVER_DBG_DRAW
    unsigned numInternal = bvh->numInternalNodes();
	debugDraw(*m_rootNodeInd, numInternal);
#else
	GeoDrawer * dr = getDrawer();
    BoundingBox bb; 
	bb.setMin(ab.low.x, ab.low.y, ab.low.z);
	bb.setMax(ab.high.x, ab.high.y, ab.high.z);
	
    dr->boundingBox(bb);
#endif

#ifdef BVHSOLVER_DRAW_MESH
    glColor3f(0.f, 0.3f, 0.5f);
	//internalTimer()->stop();
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	
    glEnableClientState(GL_VERTEX_ARRAY);

	glVertexPointer(3, GL_FLOAT, 0, (GLfloat*)m_mesh->vertices());
	glDrawElements(GL_TRIANGLES, m_mesh->numTriangleFaceVertices(), GL_UNSIGNED_INT, m_mesh->triangleIndices());

	glDisableClientState(GL_VERTEX_ARRAY);
#endif
}
Пример #8
0
void scigraphics::plot::replotFloatRectangles()
{
  if ( getDrawer() == NULL )
    throw std::runtime_error( "Drawer is not initialized" );

  drawFloatRectangles();
  flush();
}
Пример #9
0
void MlUVView::drawActiveBound()
{
	if(!FeatherLibrary) return;

	MlFeather * f = FeatherLibrary->selectedFeatherExample();
	if(!f) return;
	
	getDrawer()->boundingRectangle(f->getBoundingRectangle());
}
Пример #10
0
void MlUVView::loadImageBackground(const std::string & name)
{
	if(!MlFeather::ColorTextureFile.open(name)) return;
	MlFeather::ColorTextureFile.verbose();
	makeCurrent();
	m_texId = getDrawer()->loadTexture(m_texId, &MlFeather::ColorTextureFile);
	doneCurrent();
	update();
	emit shapeChanged();
}
void ParticleSystemCore::fill(DrawableStatsAttachment *pStat)
{
    if(getDrawer() == NULL)
    {
        FINFO(("ParticleSystemCore::fill(DrawableStatsAttachment *): "
               "No Drawer Attached.\n"));

        return;
    }
    if(getSystem() == NULL)
    {
        FINFO(("ParticleSystemCore::fill(DrawableStatsAttachment *): "
               "No System Attached.\n"));

        return;
    }

    getDrawer()->fill(pStat, getSystem(), *getMFSort());
}
Пример #12
0
void MlUVView::drawVaneVectors(BaseVane * vane)
{
	GeoDrawer * dr = getDrawer();
	for(unsigned j = 0; j <= vane->gridU(); j++) {
		for(unsigned k = 0; k < vane->gridV(); k++) {
			Vector3F cv0 = *vane->railCV(j, k) * 32.f;
			Vector3F cv1 = *vane->railCV(j, k+1) * 32.f;
			
			dr->arrow(cv0, cv1);
		}
	}
}
void ParticleSystemCore::drawPrimitives (DrawEnv *pEnv)
{
    //If I have a Drawer tell it to draw the particles
    if(getDrawer() != NULL && getSystem() != NULL)
    {
		
		checkAndInitializeSort();
		sortParticles(pEnv);

		getDrawer()->draw(pEnv, getSystem(), *getMFSort());
    }
    else
    {
        if(getDrawer() == NULL)
        {
            FWARNING(("ParticleSystemCore::draw: ParticleSystemDrawer is Null."));
        }
        if(getSystem() == NULL)
        {
            FWARNING(("ParticleSystemCore::draw: ParticleSystem is Null."));
        }
    }
}
Пример #14
0
void GLWidget::clientDraw()
{
    if(m_thread->numLoops() < WorldThread::NumSubsteps) {
        emit updatePhysics();
        return;
    }
    
    std::stringstream sst;
	sst.str("");
	sst<<"fps: "<<frameRate();
    hudText(sst.str(), 1);
    
#if DRGDRW
    if(m_isPhysicsRunning) m_interface->draw(m_world, getDrawer());
#else
    if(m_isPhysicsRunning) {
        emit updatePhysics();
        m_interface->draw(m_world, getDrawer());
        m_world->dbgDraw();
    }
#endif
    //else m_interface->drawFaulty(m_world, getDrawer());
}
Пример #15
0
void Base3DView::initializeGL()
{
#ifdef WIN32   
    if(gExtensionInit()) qDebug()<<"GL Extensions checked.";
#endif
	qglClearColor(m_backgroundColor.dark());

    glEnable(GL_DEPTH_TEST);
	glEnable(GL_COLOR_MATERIAL);
	glEnable(GL_TEXTURE_2D);
	glShadeModel(GL_SMOOTH);
	glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
	glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
    // glEnable(GL_MULTISAMPLE);
	glDepthFunc(GL_LEQUAL);
	getDrawer()->initializeProfile();
	m_hud->reset();
	
	clientInit();
}
Пример #16
0
void MlUVView::drawControlVectors(MlFeather * f)
{
	Vector3F baseP(f->baseUV());
	GeoDrawer * dr = getDrawer();
	
	glPushMatrix();
    Matrix44F s;
	s.setTranslation(baseP);
	
	float * quill = f->getQuilly();
	Vector3F b, a;
	Vector2F *d;
	for(short i=0; i <= f->numSegment(); i++) {
	    dr->useSpace(s);
		
		a.setZero();
		d = f->uvDisplaceAt(i, 0);
		for(short j = 0; j < 3; j++) {
			b = d[j];
			dr->arrow(a, a + b);
			a += b;
		}
		
		a.setZero();
		d = f->uvDisplaceAt(i, 1);
		for(short j = 0; j < 3; j++) {
			b = d[j];
			dr->arrow(a, a + b);
			a += b;
		}
		
		a.setZero();
		b.set(0.f, quill[i], 0.f);
		
		if(i<f->numSegment()) dr->arrow(a, b);
		
		s.setTranslation(b);
	}
	glPopMatrix();
}
Пример #17
0
void scigraphics::plot::replot()
{
  if ( getDrawer() == NULL )
    throw std::runtime_error( "Drawer is not initialized" );

  prepareForPainting();

  clearPlotArea();
  drawGraphicsUnderGrid();
  drawGrid();
  drawGraphicsOverGrid();
  drawSelections();
  
  clearBorders();
  drawAxis();
  drawAxisTicks();
  drawAxisLabels();
  drawAxisTitles();
  drawFloatRectangles();
  drawZoomRectangle();

  flush();
}
Пример #18
0
void MlUVView::drawBindVectors(MlFeather * f)
{
	GeoDrawer * dr = getDrawer();
	const Vector3F baseP(f->baseUV());
	
	glPushMatrix();
    Matrix44F s;
	s.setTranslation(baseP);
	
	float * quill = f->getQuilly();
	Vector3F b;
	for(short i=0; i < f->numSegment(); i++) {
	    dr->useSpace(s);
		
		for(short j=0; j < f->numBind(i); j++) {
			DeformableFeather::BindCoord *bind = f->getBind(i, j);
			dr->arrow(Vector3F(0.f, 0.f, 0.f), bind->_objP * 32.f);
		}
		
		b.set(0.f, quill[i], 0.f);
		s.setTranslation(b);
	}
	glPopMatrix();
}
Пример #19
0
void GLWidget::clientDraw()
{
	updatePerspectiveView();
	getDrawer()->frustum(perspectiveView()->frustum() );
	m_scene->draw(getDrawer() );
}
Пример #20
0
void GLWidget::clientInit()
{	
    CudaDynamicWorld::DbgDrawer = new WorldDbgDraw(getDrawer());
    m_world->initOnDevice();
    startPhysics();
}
Пример #21
0
GLWidget::GLWidget(QWidget *parent) : Base3DView(parent)
{
    m_scene = new SceneContainer(getDrawer() );
}
Пример #22
0
void GLWidget::debugDraw(unsigned rootInd, unsigned numInternal)
{
#ifdef BVHSOLVER_DBG_DRAW
	if(!m_solver->isValid()) return;
	
	GeoDrawer * dr = getDrawer();
	// qDebug()<<" root at "<< (*m_rootNodeInd & (~0x80000000));
	Aabb ab; BoundingBox bb; 
#ifdef BVHSOLVER_DBG_DRAW_BOX
	Aabb * internalBoxes = (Aabb *)m_displayInternalAabbs->data();
	Aabb * leafBoxes = (Aabb *)m_displayLeafAabbs->data();
	int * levels = (int *)m_displayInternalDistance->data();
	KeyValuePair * leafHash = (KeyValuePair *)m_displayLeafHash->data();
	int2 * internalNodeChildIndices = (int2 *)m_internalChildIndices->data();
	
	// std::cout<<" "<<numInternal/2<<" "<<byte_to_binary(leafHash[numInternal/2].key)<<" "<<leafHash[numInternal/2].value<<"\n";
	
	int stack[128];
	stack[0] = rootInd;
	int stackSize = 1;
	int maxStack = 1;
	int touchedLeaf = 0;
	int touchedInternal = 0;
	while(stackSize > 0) {
		int internalOrLeafNodeIndex = stack[ stackSize - 1 ];
		stackSize--;
		
		int isLeaf = isLeafNode(internalOrLeafNodeIndex);	//Internal node if false
		uint bvhNodeIndex = getIndexWithInternalNodeMarkerRemoved(internalOrLeafNodeIndex);
		
		int bvhRigidIndex = (isLeaf) ? leafHash[bvhNodeIndex].value : -1;
		
		Aabb bvhNodeAabb = (isLeaf) ? leafBoxes[bvhRigidIndex] : internalBoxes[bvhNodeIndex];

		{
			if(isLeaf) {
#ifdef BVHSOLVER_DBG_DRAW_LEAFBOX
				glColor3f(.5, 0., 0.);
				ab = bvhNodeAabb;
				bb.setMin(ab.low.x, ab.low.y, ab.low.z);
				bb.setMax(ab.high.x, ab.high.y, ab.high.z);
				dr->boundingBox(bb);
#endif
				touchedLeaf++;
			}
			else {
#ifdef BVHSOLVER_DBG_DRAW_INTERNALBOX_TO_LEVEL
				glColor3f(.5, .65, 0.);
				if(levels[bvhNodeIndex] > m_displayLevel) continue;
				ab = bvhNodeAabb;
				bb.setMin(ab.low.x, ab.low.y, ab.low.z);
				bb.setMax(ab.high.x, ab.high.y, ab.high.z);
				dr->boundingBox(bb);
#endif
				touchedInternal++;
				if(stackSize + 2 > 128)
				{
					//Error
				}
				else
				{
				    stack[ stackSize ] = internalNodeChildIndices[bvhNodeIndex].x;
					stackSize++;
					stack[ stackSize ] = internalNodeChildIndices[bvhNodeIndex].y;
					stackSize++;
					
					if(stackSize > maxStack) maxStack = stackSize;
				}
			}
		}
		
	} 
	
	//qDebug()<<"max stack "<<maxStack<<" touch leaf "<<touchedLeaf<<" touchedInternal "<<touchedInternal;
#endif	

#ifdef BVHSOLVER_DBG_DRAW_LEAFHASH
	glBegin(GL_LINES);
	int nzero = 0;
	for(unsigned i=0; i < numInternal; i++) {
		float red = (float)i/(float)numInternal;
		
		if(leafHash[i].value > numInternal) {
			qDebug()<<"invalid hash value "<<leafHash[i].value;
			nzero++;
			continue;
		}
		
		glColor3f(red, 1.f - red, 0.f);
		Aabb a0 = leafBoxes[leafHash[i].value];
		glVertex3f(a0.low.x * 0.5f + a0.high.x * 0.5f, a0.low.y * 0.5f + a0.high.y * 0.5f + 0.2f, a0.low.z * 0.5f + a0.high.z * 0.5f);
        
		Aabb a1 = leafBoxes[leafHash[i+1].value];
		glVertex3f(a1.low.x * 0.5f + a1.high.x * 0.5f, a1.low.y * 0.5f + a1.high.y * 0.5f + 0.2f, a1.low.z * 0.5f + a1.high.z * 0.5f);
        
	}
	glEnd();	
	if(nzero > 0) qDebug()<<"n zero code "<<nzero;
#endif

#endif

#ifdef BVHSOLVER_DBG_DRAW_RAY
    RayInfo * rays = m_ray->getRays();
	const unsigned nr = m_ray->numRays();
	glColor3f(0.f, 0.5f, 0.2f);
	glBegin(GL_LINES);
	for(unsigned i=0; i < nr; i++) {
		RayInfo & r = rays[i];
		glVertex3f(r.origin.x, r.origin.y, r.origin.z);
		glVertex3f(r.destiny.x, r.destiny.y, r.destiny.z);
		
		Vector3F a(r.destiny.x - r.origin.x, r.destiny.y - r.origin.y, r.destiny.z - r.origin.z);
		// qDebug()<<" "<<a.length();
	}
	glEnd();
#endif
}
Пример #23
0
GLWidget::GLWidget(QWidget *parent) : Base3DView(parent)
{
	m_mesh = new SimpleMesh;
	m_ray = new RayTest;
	m_particles = new CudaParticleSystem;
	m_particles->createParticles(10 * 20 * 10);

	int i, j, k;
	Vector3F * p = (Vector3F *)m_particles->position();
	for(k=0; k < 10; k++)
	    for(j=0; j < 20; j++)
	        for(i=0; i < 10; i++) {
	            p->x = 2.5f * i;
	            p->y = 2.5f * j + 100.f;
	            p->z = 2.5f * k;
	            p++;
	        }
	Vector3F * v = (Vector3F *)m_particles->velocity();
	for(i=0; i < 2000; i++) v[i].set(0.f, 10.f, 10.f);
	Vector3F * f = (Vector3F *)m_particles->force();
	for(i=0; i < 2000; i++) f[i].setZero();
	
	m_solver = new BvhSolver;
	m_displayLevel = 3;

	qDebug()<<"num vertices "<<m_mesh->numVertices();
	qDebug()<<"num triangles "<<m_mesh->numTriangles();
	qDebug()<<"num ray tests "<<(IRAYDIM * IRAYDIM);
	
	m_tetra = new CudaTetrahedronSystem;
	m_tetra->create(2200, 1.f, 1.f);
	
	float * hv = &m_tetra->hostV()[0];
	
	const unsigned grdx = 43;
	for(j=0; j < 32; j++) {
		for(i=0; i<grdx; i++) {
			Vector3F base(2.f * i, 2.f * j, 0.5f * i);
			Vector3F right = base + Vector3F(1.75f, 0.f, 0.f);
			Vector3F front = base + Vector3F(0.f, 0.f, 1.75f);
			Vector3F top = base + Vector3F(0.f, 1.75f, 0.f);
			
			m_tetra->addPoint(&base.x);
			hv[0] = 30.f * (((float)(rand() % 199))/199.f - .5f);
			hv[1] = 30.f * (((float)(rand() % 199))/199.f - .5f);
			hv[2] = 33.f * (((float)(rand() % 199))/199.f - .5f);
			hv+=3;
			m_tetra->addPoint(&right.x);
			hv[0] = 30.f * (((float)(rand() % 199))/199.f - .5f);
			hv[1] = 38.f * (((float)(rand() % 199))/199.f - .5f);
			hv[2] = 35.f * (((float)(rand() % 199))/199.f - .5f);
			hv+=3;
			m_tetra->addPoint(&top.x);
			hv[0] = 30.f * (((float)(rand() % 199))/199.f - .5f);
			hv[1] = 38.f * (((float)(rand() % 199))/199.f - .5f);
			hv[2] = 35.f * (((float)(rand() % 199))/199.f - .5f);
			hv+=3;
			m_tetra->addPoint(&front.x);
			hv[0] = 30.f * (((float)(rand() % 199))/199.f - .5f);
			hv[1] = 38.f * (((float)(rand() % 199))/199.f - .5f);
			hv[2] = 35.f * (((float)(rand() % 199))/199.f - .5f);
			hv+=3;

			unsigned b = (j * grdx + i) * 4;
			m_tetra->addTetrahedron(b, b+1, b+2, b+3);
			
			m_tetra->addTriangle(b, b+2, b+1);
			m_tetra->addTriangle(b, b+1, b+3);
			m_tetra->addTriangle(b, b+3, b+2);
			m_tetra->addTriangle(b+1, b+2, b+3);
//	 2
//	 | \ 
//	 |  \
//	 0 - 1
//  /
// 3 		
		}
	}	
	
	/*for(j=0; j < 32; j++) {
		for(i=0; i<32; i++) {
		    float * v = &m_tetra->hostV()[(j*32 + i)*3];
		    std::cout<<" "<<v[0]<<" "<<v[1]<<" "<<v[2]<<"\n";
		}	
	}*/
	qDebug()<<"tetra n tet "<<m_tetra->numTetradedrons();
	qDebug()<<"tetra n p "<<m_tetra->numPoints();
	qDebug()<<"tetra n tri "<<m_tetra->numTriangles();
	
	m_drawBvh = new DrawBvh;
	m_drawBvh->setDrawer(getDrawer());
	m_drawBvh->setBvh(m_tetra);
	
	m_broadphase = new CudaBroadphase;
	m_broadphase->addBvh(m_tetra);
	
	m_drawBvh->setBroadphase(m_broadphase);
}
Пример #24
0
void GLWidget::clientInit()
{	
	AdeniumWorld::DbgDrawer = new WorldDbgDraw(getDrawer());
    m_world->initOnDevice();
}
Пример #25
0
GLWidget::GLWidget(QWidget *parent) : Base3DView(parent)
{
    m_dbgDraw = new DrawNp;
    m_dbgDraw->setDrawer(getDrawer());
	m_solver = new ContactThread;
}
Пример #26
0
void MlUVView::drawFeather(MlFeather * f)
{
	GeoDrawer * dr = getDrawer();
	
	const unsigned nu = f->uvVane(0)->gridU() * 3;
	const float du = 1.f / nu;
	
	glPushMatrix();
	glScalef(32.f, 32.f, 32.f);
	for(unsigned i=0; i <= nu; i++) {
		f->uvVane(0)->setU(du * i);
		dr->smoothCurve(*f->uvVane(0)->profile(), 2);
		f->uvVane(1)->setU(du * i);
		dr->smoothCurve(*f->uvVane(1)->profile(), 2);
	}
	glPopMatrix();
	return;
/*	
	Vector3F baseP(f->baseUV());
	
	
	glPushMatrix();
    Matrix44F s;
	s.setTranslation(baseP);
	
	float * quill = f->getQuilly();
	
	Vector3F a, b;
	
	const unsigned ncv = f->numSegment() + 1;
	
	BezierCurve quillC;
	quillC.createVertices(ncv);
	quillC.m_cvs[0] = s.transform(b);
	
	for(int i = 0; i < f->numSegment(); i++) {
	    b.set(0.f, quill[i], 0.f);
		quillC.m_cvs[i + 1] = s.transform(b);
		s.translate(b);
	}
		
	quillC.computeKnots();
	
	dr->linearCurve(quillC);
	
	dr->smoothCurve(quillC, 2);
	
	
	BezierCurve eRC, eLC, fRC, fLC, gRC, gLC;

	eRC.createVertices(ncv);
	eLC.createVertices(ncv);
	fRC.createVertices(ncv);
	fLC.createVertices(ncv);
	gRC.createVertices(ncv);
	gLC.createVertices(ncv);
	s.setTranslation(baseP);
	
	Vector2F pv;
	for(int i = 0; i <= f->numSegment(); i++) {
		b.set(0.f, quill[i], 0.f);
		Vector2F * vanes = f->getUvDisplaceAt(i, 0);
		pv = vanes[0];
	    eRC.m_cvs[i] = s.transform(Vector3F(pv));
		pv += vanes[1];
		fRC.m_cvs[i] = s.transform(Vector3F(pv));
		pv += vanes[2];
		gRC.m_cvs[i] = s.transform(Vector3F(pv));
		vanes = f->getUvDisplaceAt(i, 1);
		pv = vanes[0];
	    eLC.m_cvs[i] = s.transform(Vector3F(pv));
		pv += vanes[1];
		fLC.m_cvs[i] = s.transform(Vector3F(pv));
		pv += vanes[2];
		gLC.m_cvs[i] = s.transform(Vector3F(pv));
		s.translate(b);
	}
	eRC.computeKnots();
	fRC.computeKnots();
	gRC.computeKnots();
	eLC.computeKnots();
	fLC.computeKnots();
	gLC.computeKnots();
	
	dr->smoothCurve(gRC, 4);
	dr->smoothCurve(gLC, 4);
	
	const float delta = 1.f /(f->numSegment() * 2.f);
	for(int i=0; i <= f->numSegment() * 2; i++) {
		float t = delta * i;
		BezierCurve vaneRC;
		vaneRC.createVertices(4);
		vaneRC.m_cvs[0] = quillC.interpolate(t);
		vaneRC.m_cvs[1] = eRC.interpolate(t);
		vaneRC.m_cvs[2] = fRC.interpolate(t);
		vaneRC.m_cvs[3] = gRC.interpolate(t);
		vaneRC.computeKnots();
		dr->smoothCurve(vaneRC, 4);
		
		vaneRC.m_cvs[0] = quillC.interpolate(t);
		vaneRC.m_cvs[1] = eLC.interpolate(t);
		vaneRC.m_cvs[2] = fLC.interpolate(t);
		vaneRC.m_cvs[3] = gLC.interpolate(t);
		vaneRC.computeKnots();
		dr->smoothCurve(vaneRC, 4);
	}

    glPopMatrix();*/
}