inline static void renderGridCells(const Array& vertices)
{
/* Get vertex array size: */
const Index& numVertices=vertices.getSize();
Index index;
/* Render grid lines along y direction: */
for(index[0]=0;index[0]<numVertices[0];++index[0])
{
glBegin(GL_LINE_STRIP);
for(index[1]=0;index[1]<numVertices[1];++index[1])
glVertex(vertices(index).pos);
glEnd();
}
/* Render grid lines along x direction: */
for(index[1]=0;index[1]<numVertices[1];++index[1])
{
glBegin(GL_LINE_STRIP);
for(index[0]=0;index[0]<numVertices[0];++index[0])
glVertex(vertices(index).pos);
glEnd();
}
}
void emitStrip(Vector v[6], float s1, float s2, float dt, int count, int depth)
{
if(depth > 0){
emitStrip(v, s1, (s1+s2)/2, dt/2, count*2-1, depth-1);
emitStrip(v, (s1+s2)/2, s2, dt/2, count*2-1, depth-1);
}else{
glBegin(GL_TRIANGLE_STRIP);
/*
static Color colors[] = {
Color(255,255,0),
Color(0,255,255),
Color(255,0,255),
Color(255,255,255),
Color(0,255,0)
};
static int i = 0;
glColor(colors[(i++)%5]);
*/
for(int i=0; i<count; i++){
Vector v1 = sampleStrip(v, s1, i*dt);
Vector v2 = sampleStrip(v, s2, i*dt);
v1 /= length(v1);
v2 /= length(v2);
glNormal(v1);
glTexCoord3f(v1.x, v1.y, v1.z);
glVertex(v1);
glNormal(v2);
glTexCoord3f(v2.x, v2.y, v2.z);
glVertex(v2);
}
glEnd();
}
}
static void
draw_grid(int xblocks, int zblocks, double xdim, double zdim)
{
Vec3 v[2];
int i;
glPushAttrib(GL_LINE_BIT);
glLineWidth(2);
glBegin(GL_LINES);
v[0] = Vec3(-xdim*0.5, 0, 0);
v[1] = Vec3( xdim*0.5, 0, 0);
for (i=0; i<=zblocks; i++){
v[0][2] = v[1][2] = -zdim*0.5 + i*(zdim/zblocks);
glVertex(v[0]);
glVertex(v[1]);
}
v[0] = Vec3(0, 0, zdim*0.5);
v[1] = Vec3(0, 0, -zdim*0.5);
for (i=0; i<=xblocks; i++){
v[0][0] = v[1][0] = -xdim*0.5 + i*(xdim/xblocks);
glVertex(v[0]);
glVertex(v[1]);
}
glEnd();
glPopAttrib();
}
void Margin::draw(GLContextData& contextData) const
{
/* Draw the grandparent class widget: */
Container::draw(contextData);
if(child!=0)
{
/* Draw the margin around the child widget: */
glBegin(GL_QUAD_STRIP);
glColor(backgroundColor);
glNormal3f(0.0f,0.0f,1.0f);
glVertex(child->getExterior().getCorner(0));
glVertex(getInterior().getCorner(0));
glVertex(child->getExterior().getCorner(1));
glVertex(getInterior().getCorner(1));
glVertex(child->getExterior().getCorner(3));
glVertex(getInterior().getCorner(3));
glVertex(child->getExterior().getCorner(2));
glVertex(getInterior().getCorner(2));
glVertex(child->getExterior().getCorner(0));
glVertex(getInterior().getCorner(0));
glEnd();
/* Draw the child widgets: */
child->draw(contextData);
}
}
void SketchingTool::display(GLContextData& contextData) const
{
/* Set up OpenGL state: */
glPushAttrib(GL_ENABLE_BIT|GL_LINE_BIT);
glDisable(GL_LIGHTING);
/* Go to navigational coordinates: */
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glMultMatrix(getDisplayState(contextData).modelviewNavigational);
/* Render all curves: */
for(std::vector<Curve*>::const_iterator cIt=curves.begin();cIt!=curves.end();++cIt)
{
const Curve* curve=*cIt;
glLineWidth(curve->lineWidth);
glColor(curve->color);
glBegin(GL_LINE_STRIP);
for(std::vector<Curve::ControlPoint>::const_iterator cpIt=curve->controlPoints.begin();cpIt!=curve->controlPoints.end();++cpIt)
glVertex(cpIt->pos);
if(active&&curve==currentCurve)
glVertex(currentPoint);
glEnd();
}
/* Go back to physical coordinates: */
glPopMatrix();
/* Reset OpenGL state: */
glPopAttrib();
}
void GrapheinClient::GrapheinTool::display(GLContextData& contextData) const
{
if(client==0)
return;
if(active)
{
/* Retrieve the current curve: */
CurveMap::Iterator cIt=client->localCurves.findEntry(currentCurveId);
if(!cIt.isFinished())
{
/* Render the last segment of the current curve: */
glPushAttrib(GL_ENABLE_BIT|GL_LINE_BIT);
glDisable(GL_LIGHTING);
glLineWidth(cIt->getDest()->lineWidth);
glPushMatrix();
glMultMatrix(Vrui::getNavigationTransformation());
glColor(cIt->getDest()->color);
glBegin(GL_LINES);
glVertex(lastPoint);
glVertex(currentPoint);
glEnd();
glPopMatrix();
glPopAttrib();
}
}
}
///TODO: render the system (ie draw the particles)
void ClothSystem::draw()
{
for (int i = 0; i < m_numParticles; i++) {
Vector3f pos = m_vVecState[i*2];
if (areParticlesVisible)
{
glPushMatrix();
glTranslatef(pos[0], pos[1], pos[2] );
drawDove();
glPopMatrix();
}
if (areSpringsVisible)
{
std::vector<Spring> springs = springTies[i];
for (int k = 0; k < springs.size(); ++k)
{
glBegin(GL_LINES);
glVertex(pos);
glVertex(m_vVecState[springs[k].particleInd2]);
glEnd();
}
}
}
}
void drawMesh(carve::mesh::Mesh<3> *mesh, float r, float g, float b, float a) {
glColor4f(r, g, b, a);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLES);
std::vector<carve::mesh::Vertex<3> *> v;
for (size_t i = 0, l = mesh->faces.size(); i != l; ++i) {
carve::mesh::Face<3> *f = mesh->faces[i];
if (f->nVertices() == 3) {
glNormal3dv(f->plane.N.v);
f->getVertices(v);
glVertex(v[0]->v);
glVertex(v[1]->v);
glVertex(v[2]->v);
}
}
glEnd();
for (size_t i = 0, l = mesh->faces.size(); i != l; ++i) {
carve::mesh::Face<3> *f = mesh->faces[i];
if (f->nVertices() != 3) {
drawFace(f, cRGBA(r, g, b, a));
}
}
}
void SixDofWithScaleNavigationToolFactory::initContext(GLContextData& contextData) const
{
/* Create a new data item: */
DataItem* dataItem=new DataItem;
contextData.addDataItem(this,dataItem);
/* Create the tool model display list: */
glNewList(dataItem->modelListId,GL_COMPILE);
/* Set up OpenGL state: */
glPushAttrib(GL_ENABLE_BIT|GL_POLYGON_BIT|GL_LINE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glLineWidth(1.0f);
glColor3f(1.0f,1.0f,1.0f);
/* Render a sphere of radius scaleDeviceDistance around the scaling device's position: */
glDrawSphereIcosahedron(scaleDeviceDistance,3);
/* Render the scaling direction: */
glLineWidth(3.0f);
glColor3f(1.0f,0.0f,0.0f);
glBegin(GL_LINES);
Point pos=Point::origin;
glVertex(pos);
pos+=deviceScaleDirection*scaleDeviceDistance*Scalar(1.25);
glVertex(pos);
glEnd();
/* Reset OpenGL state: */
glPopAttrib();
glEndList();
}
void BiovisionDisplay::draw(const KinematicModel<BiovisionJoint> &model, const Vector3D &colour, bool drawAxis)
{
for(int i = 0; i < model.njoints(); i++)
{
const BiovisionJoint &joint = model.joints(i);
if(drawAxis)
{
glPushMatrix();
glTranslate(joint.global_position());
glRotate(joint.global_orientation());
glBegin(GL_LINES);
glColor3f(1.0, 0.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(20.0, 0., 0.0);
glColor3f(0.0, 1.0, 0.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 20.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 0.0, 20.0);
glEnd();
glPopMatrix();
}
if(joint.parent() >= 0)
{
glBegin(GL_LINES);
glVertex(joint.global_position());
glVertex(model.getParent(joint).global_position());
glEnd();
Vector3D global_direction = (joint.global_position()-model.getParent(joint).global_position()).direction();
double length = joint.local_position().length();
glColor(colour);
glPushMatrix();
glTranslate(joint.global_position());
glTranslate(-global_direction*length*0.5);
//align bone
Vector3D zAxis = Vector3D(0.0, 0.0, 1.0);
Vector3D newAxis = zAxis ^ global_direction;
double newAngle = acos(zAxis *global_direction);
glRotateRad(newAngle, newAxis);
//draw bone
GLUquadricObj *qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj, GLU_FILL);
gluQuadricNormals(qobj, GLU_SMOOTH);
glScalef(0.25, 0.25, 1.0);
gluSphere(qobj, length*0.5, 20, 20);
gluDeleteQuadric(qobj);
glPopMatrix();
}
}
}
void drawEdges(carve::mesh::Mesh<3> *mesh, double alpha, bool draw_edgeconn) {
glColor4f(1.0, 0.0, 0.0, alpha);
glBegin(GL_LINES);
for (size_t i = 0, l = mesh->closed_edges.size(); i != l; ++i) {
carve::mesh::Edge<3> *edge = mesh->closed_edges[i];
glVertex(edge->v1()->v);
glVertex(edge->v2()->v);
}
glEnd();
std::unordered_map<std::pair<const carve::mesh::Vertex<3> *, const carve::mesh::Vertex<3> *>, int> colour;
if (draw_edgeconn) {
for (size_t i = 0, l = mesh->closed_edges.size(); i != l; ++i) {
const carve::mesh::Edge<3> *edge = mesh->closed_edges[i];
int c = colour[std::make_pair(std::min(edge->v1(), edge->v2()), std::max(edge->v1(), edge->v2()))]++;
drawEdgeConn(edge, (c&1) ? 0.0 : 1.0, (c&2) ? 0.0 : 1.0, (c&4) ? 1.0 : 0.0, alpha);
}
}
glColor4f(1.0, 1.0, 0.0, alpha);
glBegin(GL_LINES);
for (size_t i = 0, l = mesh->open_edges.size(); i != l; ++i) {
carve::mesh::Edge<3> *edge = mesh->open_edges[i];
glVertex(edge->v1()->v);
glVertex(edge->v2()->v);
}
glEnd();
}
void CylinderPrimitive::glRenderAction(GLContextData& contextData) const
{
/* Retrieve the data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
glPushAttrib(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ENABLE_BIT|GL_LINE_BIT|GL_POLYGON_BIT);
glDisable(GL_LIGHTING);
/* Draw the cylinder's central axis: */
glLineWidth(3.0f);
glColor(surfaceColor);
glBegin(GL_LINES);
Vector z=axis*Math::div2(length);
glVertex(center-z);
glVertex(center+z);
glEnd();
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
/* Draw the surface: */
glColor(surfaceColor);
glCallList(dataItem->displayListId);
/* Draw the grid: */
glColor(gridColor);
glCallList(dataItem->displayListId+1);
glPopAttrib();
}
inline static void renderGridOutline(const Array& vertices)
{
/* Get vertex array size: */
const Index& numVertices=vertices.getSize();
Index index;
/* Render grid's outline: */
glBegin(GL_LINE_STRIP);
index[1]=0;
for(index[0]=0;index[0]<numVertices[0];++index[0])
glVertex(vertices(index).pos);
glEnd();
glBegin(GL_LINE_STRIP);
index[1]=numVertices[1]-1;
for(index[0]=0;index[0]<numVertices[0];++index[0])
glVertex(vertices(index).pos);
glEnd();
glBegin(GL_LINE_STRIP);
index[0]=0;
for(index[1]=0;index[1]<numVertices[1];++index[1])
glVertex(vertices(index).pos);
glEnd();
glBegin(GL_LINE_STRIP);
index[0]=numVertices[0]-1;
for(index[1]=0;index[1]<numVertices[1];++index[1])
glVertex(vertices(index).pos);
glEnd();
}
void LoadingScreen::draw_progress_indicator(void)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
vec2_ary_t points = Procedural::circle_points(
0.0,0.0,0.2f,
64,1,1,
m_counter * m_step
);
vec2_ary_t points2 = Procedural::circle_points(
0.0,0.0,0.05f,
64,1,1,
m_counter * m_step
);
glColor3f(0.6f,0.6f,1.0);
glScalef(1.0f/1.6f,-1.0,0.0);
glRotatef(90,0,0,-1);
glBegin(GL_TRIANGLE_STRIP);
for(unsigned int i=0;i<points.size();++i) {
glVertex(points[i]);
glVertex(points2[i]);
}
glEnd();
}
void draw_aa_line(Line l,float width,vec4 color,float stipple)
{
// stretch line to quad
vec2 linedir = normalized(l.p2 - l.p1); // line direction vector
linedir *= 0.001 * width; // scale normalized vector with line width
vec2 p1_a = vec2(+linedir[1],-linedir[0]) + l.p1; // rotate vector 90 degrees and add to p1
vec2 p1_b = vec2(-linedir[1],+linedir[0]) + l.p1; // rotate vector 270 degrees and add to p1
vec2 p2_a = vec2(+linedir[1],-linedir[0]) + l.p2; // rotate vector 90 degrees and add to p2
vec2 p2_b = vec2(-linedir[1],+linedir[0]) + l.p2; // rotate vector 270 degrees and add to p2
float len = length(l.p2 - l.p1);
glBindTexture(GL_TEXTURE_2D,g_resources.texture_line);
len *= stipple;
g_resources.shader_line->use();
my_glUniform1f(g_resources.shader_line->get_uni_loc("stipple"),clamp_0_1(stipple));
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glColor(color);
glBegin(GL_QUADS);
glTexCoord2f(0.0,0.0); glVertex(p1_a);
glTexCoord2f(0.0,1.0); glVertex(p1_b);
glTexCoord2f(len,1.0); glVertex(p2_b);
glTexCoord2f(len,0.0); glVertex(p2_a);
glEnd();
g_resources.shader_line->unuse();
glDisable(GL_TEXTURE_2D);
}
void GLFont::String::draw(const GLFont::Vector& origin,GLContextData& contextData) const
{
/* Retrieve the context data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Render a textured quad: */
glPushAttrib(GL_TEXTURE_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,dataItem->textureObjectId);
glTexEnvMode(GLTexEnvEnums::TEXTURE_ENV,GLTexEnvEnums::BLEND);
glTexEnvColor(GLTexEnvEnums::TEXTURE_ENV,foregroundColor);
glColor(backgroundColor);
Box offsetBox=box.offset(origin);
glBegin(GL_QUADS);
glNormal3f(0.0,0.0,1.0);
glTexCoord(texCoord.getCorner(0));
glVertex(offsetBox.getCorner(0));
glTexCoord(texCoord.getCorner(1));
glVertex(offsetBox.getCorner(1));
glTexCoord(texCoord.getCorner(3));
glVertex(offsetBox.getCorner(3));
glTexCoord(texCoord.getCorner(2));
glVertex(offsetBox.getCorner(2));
glEnd();
glBindTexture(GL_TEXTURE_2D,0);
glPopAttrib();
}
void ConeNode::createList(GLContextData& renderState) const
{
Scalar h=height.getValue();
Scalar h2=Math::div2(h);
Scalar br=bottomRadius.getValue();
int ns=numSegments.getValue();
if(side.getValue())
{
/* Draw the cone side: */
glBegin(GL_QUAD_STRIP);
Scalar nScale=Scalar(1)/Math::sqrt(h*h+br*br);
glNormal(Scalar(0),br*nScale,-h*nScale);
glTexCoord2f(0.0f,1.0f);
glVertex(Scalar(0),h2,Scalar(0));
glTexCoord2f(0.0f,0.0f);
glVertex(Scalar(0),-h2,-br);
for(int i=1;i<ns;++i)
{
Scalar angle=Scalar(2)*Math::Constants<Scalar>::pi*Scalar(i)/Scalar(ns);
float texS=float(i)/float(ns);
Scalar c=Math::cos(angle);
Scalar s=Math::sin(angle);
glNormal(-s*h*nScale,br*nScale,-c*h*nScale);
glTexCoord2f(texS,1.0f);
glVertex(Scalar(0),h2,Scalar(0));
glTexCoord2f(texS,0.0f);
glVertex(-s*br,-h2,-c*br);
}
glNormal(Scalar(0),br*nScale,-h*nScale);
glTexCoord2f(1.0f,1.0f);
glVertex(Scalar(0),h2,Scalar(0));
glTexCoord2f(1.0f,0.0f);
glVertex(Scalar(0),-h2,-br);
glEnd();
}
if(bottom.getValue())
{
/* Draw the cone bottom: */
glBegin(GL_TRIANGLE_FAN);
glNormal(Scalar(0),Scalar(-1),Scalar(0));
glTexCoord2f(0.5f,0.5f);
glVertex(Scalar(0),-h2,Scalar(0));
glTexCoord2f(0.5f,0.0f);
glVertex(Scalar(0),-h2,-br);
for(int i=ns-1;i>0;--i)
{
Scalar angle=Scalar(2)*Math::Constants<Scalar>::pi*Scalar(i)/Scalar(ns);
Scalar c=Math::cos(angle);
Scalar s=Math::sin(angle);
glTexCoord2f(-float(s)*0.5f+0.5f,-float(c)*0.5f+0.5f);
glVertex(-s*br,-h2,-c*br);
}
glTexCoord2f(0.5f,0.0f);
glVertex(Scalar(0),-h2,-br);
glEnd();
}
}
void ShowLEDs::display(GLContextData& contextData) const
{
glPushAttrib(GL_ENABLE_BIT|GL_POINT_BIT);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
/* Draw the IMU as a sphere: */
glPushMatrix();
glTranslate(hmdModel.getIMU()-HMDModel::Point::origin);
glColor3f(0.5f,0.5f,1.0f);
glDrawSphereIcosahedron(0.005,4);
glPopMatrix();
/* Draw the markers as spheres: */
for(unsigned int markerIndex=0;markerIndex<hmdModel.getNumMarkers();++markerIndex)
{
glPushMatrix();
glTranslate(hmdModel.getMarkerPos(markerIndex)-HMDModel::Point::origin);
glColor3f(1.0f,0.5f,0.5f);
glDrawSphereIcosahedron(0.005,4);
glPopMatrix();
}
glDisable(GL_LIGHTING);
glPointSize(3.0f);
glLineWidth(3.0f);
/* Draw the markers emission direction vectors: */
glColor3f(0.5f,1.0f,5.0f);
glBegin(GL_LINES);
for(unsigned int markerIndex=0;markerIndex<hmdModel.getNumMarkers();++markerIndex)
{
glVertex(hmdModel.getMarkerPos(markerIndex));
glVertex(hmdModel.getMarkerPos(markerIndex)+hmdModel.getMarkerDir(markerIndex)*HMDModel::Scalar(0.03));
}
glEnd();
/* Draw the markers' IDs: */
glLineWidth(2.0f);
glColor3f(1.0f,1.0f,1.0f);
HMDModel::Point head=HMDModel::Point(Vrui::getHeadPosition());
for(unsigned int markerIndex=0;markerIndex<hmdModel.getNumMarkers();++markerIndex)
{
/* Intersect a ray from the head position to the marker position with the marker sphere: */
Geometry::Sphere<HMDModel::Scalar,3> marker(hmdModel.getMarkerPos(markerIndex),HMDModel::Scalar(0.0075));
Geometry::Ray<HMDModel::Scalar,3> ray(head,marker.getCenter()-head);
Geometry::Sphere<HMDModel::Scalar,3>::HitResult hr=marker.intersectRay(ray);
HMDModel::Point labelPos=ray(hr.getParameter());
glPushMatrix();
Vrui::Vector up=Vrui::getInverseNavigationTransformation().transform(Vrui::getUpDirection());
Vrui::Vector x=Vrui::Vector(ray.getDirection())^up;
glMultMatrix(Vrui::ONTransform::rotateAround(labelPos,Vrui::Rotation::fromBaseVectors(x,up)));
numberRenderer.drawNumber(GLNumberRenderer::Vector(labelPos.getComponents()),markerIndex,contextData,0,0);
glPopMatrix();
}
glPopAttrib();
}
inline static void highlightCell(const Cell& cell)
{
glBegin(GL_LINE_LOOP);
glVertex(cell.getVertexPosition(0));
glVertex(cell.getVertexPosition(1));
glVertex(cell.getVertexPosition(3));
glVertex(cell.getVertexPosition(2));
glEnd();
}
void Primitive::DrawDebugInObjectSpace(){
glPushAttrib(GL_DEPTH_BUFFER_BIT|GL_ENABLE_BIT|GL_LINE_BIT|GL_POINT_BIT|GL_CURRENT_BIT|GL_LIGHTING_BIT|GL_COLOR_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_BLEND);
if(showCloudSampling){
//Disegno la cloudSampling
for(int i=0;i<(int)cloudSampling.size();i++){
glColor3f(1,0,1);
glPointSize(3);
glBegin(GL_POINTS);
glVertex(cloudSampling[i]);
glEnd();
}
}
if(showCloudNearPoints){
//Disegno la cloudNearPoints
for(int i=0;i<(int)cloudNearPoints.size();i++){
glColor3f(0,1,1);
glPointSize(3);
glBegin(GL_POINTS);
glVertex(cloudNearPoints[i]);
glEnd();
}
}
if(showLines){
//Disegno Le linee:
for(int i=0;i<(int)cloudNearPoints.size();i++){
glPointSize(1);
glBegin(GL_LINES);
glColor3f(0,1,1);
glVertex(cloudNearPoints[i]);
glColor3f(1,0,1);
glVertex(cloudSampling[i]);
glEnd();
}
}
if(showSelectionMesh){
//Disegno la selectionMesh
for(int i=0;i<(int)selectionMesh->vert.size();i++){
glColor3f(1,0.5,0.25);
glPointSize(3);
glBegin(GL_POINTS);
glVertex(selectionMesh->vert[i].P());
glEnd();
}
}
glPopAttrib();
}
/* Methods: */
inline static void renderBoundingBox(const Box& box)
{
glBegin(GL_LINE_LOOP);
glVertex(box.getVertex(0));
glVertex(box.getVertex(1));
glVertex(box.getVertex(3));
glVertex(box.getVertex(2));
glEnd();
}
void DrawSelf ()
{ // draw line
SetGLColor (Color (1, 1, 1));
glLineWidth(2.0);
glBegin (GL_LINES);
glVertex (Vect (0, 0, 0));
glVertex (vertex);
glEnd ();
}
void QuadSetNode::glRenderAction(GLRenderState& renderState) const
{
/* Bail out if there are less than 4 points: */
if(coord.getValue()==0||coord.getValue()->point.getNumValues()<4)
return;
/* Set up OpenGL state: */
renderState.enableCulling(GL_BACK);
/* Render the quad set: */
size_t numPoints=coord.getValue()->point.getNumValues();
glBegin(GL_QUADS);
std::vector<Vector>::const_iterator qnIt=quadNormals.begin();
for(size_t q=0;q+4<=numPoints;q+=4,++qnIt)
{
/* Get the quad's four corner points in counter-clockwise order: */
Point ps[4];
if(ccw.getValue())
{
for(size_t i=0;i<4;++i)
ps[i]=coord.getValue()->point.getValue(q+i);
}
else
{
for(size_t i=0;i<4;++i)
ps[i]=coord.getValue()->point.getValue(q+3-i);
}
if(pointTransform.getValue()!=0)
{
/* Transform the quad's corner points: */
for(int i=0;i<4;++i)
ps[i]=pointTransform.getValue()->transformPoint(ps[i]);
}
/* Draw the quad's front: */
glNormal(*qnIt);
for(int i=0;i<4;++i)
{
glTexCoord(quadTexCoords[i]);
glVertex(ps[i]);
}
if(!solid.getValue())
{
/* Draw the quad's back: */
glNormal(-*qnIt);
for(int i=3;i>=0;--i)
{
glTexCoord(quadTexCoords[i]);
glVertex(ps[i]);
}
}
}
glEnd();
}
void GLLabel::draw(GLContextData& contextData) const
{
/* Try listing the label with a deferred renderer: */
if(DeferredRenderer::addLabel(this))
return;
/* Retrieve the context data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Save and set up OpenGL state: */
GLbitfield attribPushMask=GL_TEXTURE_BIT;
bool lightingOn=glIsEnabled(GL_LIGHTING);
if(lightingOn)
attribPushMask|=GL_LIGHTING_BIT;
glPushAttrib(attribPushMask);
glEnable(GL_TEXTURE_2D);
if(lightingOn)
{
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);
glTexEnvMode(GLTexEnvEnums::TEXTURE_ENV,GLTexEnvEnums::MODULATE);
}
else
glTexEnvMode(GLTexEnvEnums::TEXTURE_ENV,GLTexEnvEnums::REPLACE);
/* Bind the label texture: */
glBindTexture(GL_TEXTURE_2D,dataItem->textureObjectId);
/* Check if the texture object needs to be updated: */
if(dataItem->version!=version)
{
/* Upload the string's texture image: */
font->uploadStringTexture(*this,background,foreground);
/* Update the texture version number: */
dataItem->version=version;
}
/* Draw a textured quad: */
glColor4f(1.0f,1.0f,1.0f,background[3]);
glBegin(GL_QUADS);
glNormal3f(0.0f,0.0f,1.0f);
glTexCoord(textureBox.getCorner(0));
glVertex(labelBox.getCorner(0));
glTexCoord(textureBox.getCorner(1));
glVertex(labelBox.getCorner(1));
glTexCoord(textureBox.getCorner(3));
glVertex(labelBox.getCorner(3));
glTexCoord(textureBox.getCorner(2));
glVertex(labelBox.getCorner(2));
glEnd();
/* Reset OpenGL state: */
glBindTexture(GL_TEXTURE_2D,0);
glPopAttrib();
}
void DrawSelf ()
{ // draw line
SetGLColor (Color (1, 1, 1));
glLineWidth(2.0);
glBegin (GL_LINES);
glVertex (Vect (0, 0, 0));
glVertex (vertex);
glEnd ();
// draw bar (DrawQuad draws from the bottom left corner)
DrawQuad (Vect (-Feld () -> Width () / 2, Feld () -> Height () / 2 - h, 0), Vect (m, 0, 0), Vect (0, h, 0));
}
void renderBillboard(const vec3& pUp, const vec3& pRight, const World3& pWorld, const vec3& pPosition, const vec3& pColor, real pAlpha, real pSize) {
const vec3 up = pUp * pSize;
const vec3 right = pRight * pSize;
const vec3 top = pPosition + up;
const vec3 bottom = pPosition -up;
glColor4f(pColor.getX(), pColor.getY(), pColor.getZ(), pAlpha);
glTexCoord2f(1,1); glVertex(top + right);
glTexCoord2f(0,1); glVertex(top - right);
glTexCoord2f(0,0); glVertex(bottom - right);
glTexCoord2f(1,0); glVertex(bottom + right);
}
inline static void highlightCell(const Cell& cell)
{
/* Render all grid cell faces: */
glBegin(GL_LINES);
for(int i=0;i<3;++i)
for(int j=i+1;j<4;++j)
{
glVertex(cell.getVertexPosition(i));
glVertex(cell.getVertexPosition(j));
}
glEnd();
}
inline static void renderGridCells(const DataSet& dataSet)
{
/* Render all grid cell faces: */
glBegin(GL_LINES);
for(CellIterator cIt=dataSet.beginCells();cIt!=dataSet.endCells();++cIt)
for(int i=0;i<3;++i)
for(int j=i+1;j<4;++j)
{
glVertex(cIt->getVertexPosition(i));
glVertex(cIt->getVertexPosition(j));
}
glEnd();
}
inline static void renderGridFaces(const DataSet& dataSet)
{
/* Render all grid cell faces that do not have neighbours: */
glBegin(GL_LINES);
for(CellIterator cIt=dataSet.beginCells();cIt!=dataSet.endCells();++cIt)
for(int i=0;i<3;++i)
if(!cIt->getNeighbourID(i).isValid())
{
glVertex(cIt->getVertexPosition((i+1)%3));
glVertex(cIt->getVertexPosition((i+2)%3));
}
glEnd();
}
void MouseTool::display(GLContextData& contextData) const
{
if(transformEnabled&&factory->crosshairSize>Scalar(0))
{
/* Draw crosshairs at the virtual device's current position: */
glPushAttrib(GL_ENABLE_BIT|GL_LINE_BIT);
glDisable(GL_LIGHTING);
glPushMatrix();
glMultMatrix(transformedDevice->getTransformation());
glLineWidth(3.0f);
Color lineCol=getBackgroundColor();
glColor(lineCol);
glBegin(GL_LINES);
glVertex(-factory->crosshairSize,Scalar(0),Scalar(0));
glVertex( factory->crosshairSize,Scalar(0),Scalar(0));
glVertex(Scalar(0),Scalar(0),-factory->crosshairSize);
glVertex(Scalar(0),Scalar(0), factory->crosshairSize);
glEnd();
glLineWidth(1.0f);
for(int i=0; i<3; ++i)
lineCol[i]=1.0f-lineCol[i];
glColor(lineCol);
glBegin(GL_LINES);
glVertex(-factory->crosshairSize,Scalar(0),Scalar(0));
glVertex( factory->crosshairSize,Scalar(0),Scalar(0));
glVertex(Scalar(0),Scalar(0),-factory->crosshairSize);
glVertex(Scalar(0),Scalar(0), factory->crosshairSize);
glEnd();
glPopMatrix();
glPopAttrib();
}
}
