void GlyphRenderer::renderGlyph(const Glyph& glyph,const OGTransform& transformation,const GlyphRenderer::DataItem* contextDataItem) const
{
/* Check if the glyph is enabled: */
if(glyph.enabled)
{
if(glyph.glyphType==Glyph::CURSOR)
{
/****************************
Render a texture-based glyph:
****************************/
/* Align the glyph texture with the current window's current screen: */
const DisplayState& ds=getDisplayState(contextDataItem->contextData);
glPushMatrix();
glTranslate(transformation.getTranslation());
glRotate(ds.screen->getScreenTransformation().getRotation());
/* Draw the glyph texture: */
glCallList(contextDataItem->glyphDisplayLists+glyph.glyphType);
glPopMatrix();
}
else
{
/* Render a 3D glyph: */
glPushMatrix();
glMultMatrix(transformation);
glMaterial(GLMaterialEnums::FRONT,glyph.glyphMaterial);
glCallList(contextDataItem->glyphDisplayLists+glyph.glyphType);
glPopMatrix();
}
}
}
/**
* run action of init view
*/
static void run(void) {
char initMessage[40] = "Initializing";
if (isTimerElapsed(initTimer)) {
/* set new timer */
initTimer = setUpTimer(RUN_INTERVAL);
if (intervals < 25) {
intervals++;
}
for (int i = 1; i < intervals; i++) {
strcat(initMessage,".");
}
DisplayState *displaystate = getDisplayState();
/* Select fonts */
displaystate->font = GrCreateFont((unsigned char *) FONTNAME, 14, NULL);
GrSetGCFont(displaystate->gContextID, displaystate->font);
GrText(displaystate->gWinID, displaystate->gContextID, 120, 30, initMessage, -1, GR_TFASCII | GR_TFTOP);
GrDestroyFont(displaystate->font);
}
/* Did someone turn the coffeemaker off? */
if (getSwitchState(POWER_SWITCH) == switch_off) {
#ifdef DEBUG
printf("Detected power switch to off\n");
#endif
switchOff();
}
}
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 SceneGraphViewer::display(GLContextData& contextData) const
{
/* Save OpenGL state: */
glPushAttrib(GL_ENABLE_BIT|GL_LIGHTING_BIT|GL_TEXTURE_BIT);
/* Go to navigational coordinates: */
glPushMatrix();
glLoadIdentity();
glMultMatrix(getDisplayState(contextData).modelviewNavigational);
/* Create a render state to traverse the scene graph: */
SceneGraph::GLRenderState renderState(contextData,getHeadPosition(),getNavigationTransformation().inverseTransform(getUpDirection()));
/* Traverse the scene graph: */
root->glRenderAction(renderState);
/* Restore OpenGL state: */
glPopMatrix();
glPopAttrib();
}
void GlyphRenderer::renderGlyph(const Glyph& glyph,const OGTransform& transformation,const GlyphRenderer::DataItem* contextDataItem) const
{
/* Check if the glyph is enabled: */
if(glyph.enabled)
{
if(glyph.glyphType==Glyph::CURSOR)
{
/****************************
Render a texture-based glyph:
****************************/
/* Project the given transformation's origin onto the current window's current screen: */
const DisplayState& ds=getDisplayState(contextDataItem->contextData);
Point to=transformation.getOrigin();
Ray ray(to,to-ds.viewer->getHeadPosition());
ONTransform st=ds.screen->getScreenTransformation();
Point sto=st.getOrigin();
Vector screenNormal=st.getDirection(2);
Scalar screenOffset=screenNormal*sto;
Scalar divisor=screenNormal*ray.getDirection();
if(divisor!=Scalar(0))
{
Scalar lambda=(screenOffset-screenNormal*ray.getOrigin())/divisor;
glPushMatrix();
glTranslate(ray(lambda)-sto);
glMultMatrix(st);
glCallList(contextDataItem->glyphDisplayLists+glyph.glyphType);
glPopMatrix();
}
}
else
{
/* Render a 3D glyph: */
glPushMatrix();
glMultMatrix(transformation);
glMaterial(GLMaterialEnums::FRONT,glyph.glyphMaterial);
glCallList(contextDataItem->glyphDisplayLists+glyph.glyphType);
glPopMatrix();
}
}
}
/**
* activate action of init view
*/
static void activate(void) {
/* turn of power led */
updateLed(POWER_LED,led_on);
/* reset init wait intervals */
intervals = 0;
/* start Timer */
initTimer = setUpTimer(RUN_INTERVAL);
DisplayState *displaystate = getDisplayState();
displaystate->gContextID = GrNewGC();
/* Back- Foreground color related stuff */
GrSetGCForeground(displaystate->gContextID, YELLOW);
GrSetGCUseBackground(displaystate->gContextID, GR_FALSE);
/* Select fonts */
displaystate->font = GrCreateFont((unsigned char *) FONTNAME, 14, NULL);
GrSetGCFont(displaystate->gContextID, displaystate->font);
GrText(displaystate->gWinID, displaystate->gContextID, 120, 30, "Initializing", -1, GR_TFASCII | GR_TFTOP);
GrDestroyFont(displaystate->font);
}
/**
* deactivate action of init view
*/
static void deactivate(void) {
DisplayState *displaystate = getDisplayState();
/*Clear screen*/
GrClearWindow(displaystate->gWinID,GR_FALSE);
}
void PlaneSnapInputDeviceTool::display(GLContextData& contextData) const
{
if(numSelectedPoints>0)
{
/* Set up and save OpenGL state: */
GLboolean lightingEnabled=glIsEnabled(GL_LIGHTING);
if(lightingEnabled)
glDisable(GL_LIGHTING);
GLfloat lineWidth;
glGetFloatv(GL_LINE_WIDTH,&lineWidth);
/* Calculate the marker size: */
Scalar markerSize=factory->markerSize;
markerSize/=getNavigationTransformation().getScaling();
/* Go to navigational coordinates: */
glPushMatrix();
glLoadIdentity();
glMultMatrix(getDisplayState(contextData).modelviewNavigational);
/* Determine the marker color: */
Color bgColor=getBackgroundColor();
Color fgColor;
for(int i=0;i<3;++i)
fgColor[i]=1.0f-bgColor[i];
fgColor[3]=bgColor[3];
/* Mark all measurement points: */
glLineWidth(3.0f);
glBegin(GL_LINES);
glColor(bgColor);
for(int i=0;i<numSelectedPoints;++i)
{
glVertex(selectedPoints[i][0]-markerSize,selectedPoints[i][1],selectedPoints[i][2]);
glVertex(selectedPoints[i][0]+markerSize,selectedPoints[i][1],selectedPoints[i][2]);
glVertex(selectedPoints[i][0],selectedPoints[i][1]-markerSize,selectedPoints[i][2]);
glVertex(selectedPoints[i][0],selectedPoints[i][1]+markerSize,selectedPoints[i][2]);
glVertex(selectedPoints[i][0],selectedPoints[i][1],selectedPoints[i][2]-markerSize);
glVertex(selectedPoints[i][0],selectedPoints[i][1],selectedPoints[i][2]+markerSize);
}
glEnd();
glLineWidth(1.0f);
glBegin(GL_LINES);
glColor(fgColor);
for(int i=0;i<numSelectedPoints;++i)
{
glVertex(selectedPoints[i][0]-markerSize,selectedPoints[i][1],selectedPoints[i][2]);
glVertex(selectedPoints[i][0]+markerSize,selectedPoints[i][1],selectedPoints[i][2]);
glVertex(selectedPoints[i][0],selectedPoints[i][1]-markerSize,selectedPoints[i][2]);
glVertex(selectedPoints[i][0],selectedPoints[i][1]+markerSize,selectedPoints[i][2]);
glVertex(selectedPoints[i][0],selectedPoints[i][1],selectedPoints[i][2]-markerSize);
glVertex(selectedPoints[i][0],selectedPoints[i][1],selectedPoints[i][2]+markerSize);
}
glEnd();
/* Restore OpenGL state: */
glPopMatrix();
glLineWidth(lineWidth);
if(lightingEnabled)
glEnable(GL_LIGHTING);
}
}
void Cursor::draw(sf::RenderTarget &window) const
{
if (getDisplayState())
window.draw(_cursor);
}
