void DrawDepthMap(const xn::DepthMetaData& dmd, const xn::SceneMetaData& smd) { static bool bInitialized = false; static GLuint depthTexID; static unsigned char* pDepthTexBuf; static int texWidth, texHeight; float topLeftX; float topLeftY; float bottomRightY; float bottomRightX; float texXpos; float texYpos; if(!bInitialized) { texWidth = getClosestPowerOfTwo(dmd.XRes()); texHeight = getClosestPowerOfTwo(dmd.YRes()); // printf("Initializing depth texture: width = %d, height = %d\n", texWidth, texHeight); depthTexID = initTexture((void**)&pDepthTexBuf,texWidth, texHeight) ; // printf("Initialized depth texture: width = %d, height = %d\n", texWidth, texHeight); bInitialized = true; topLeftX = dmd.XRes(); topLeftY = 0; bottomRightY = dmd.YRes(); bottomRightX = 0; texXpos =(float)dmd.XRes()/texWidth; texYpos =(float)dmd.YRes()/texHeight; memset(texcoords, 0, 8*sizeof(float)); texcoords[0] = texXpos, texcoords[1] = texYpos, texcoords[2] = texXpos, texcoords[7] = texYpos; } unsigned int nValue = 0; unsigned int nHistValue = 0; unsigned int nIndex = 0; unsigned int nX = 0; unsigned int nY = 0; unsigned int nNumberOfPoints = 0; XnUInt16 g_nXRes = dmd.XRes(); XnUInt16 g_nYRes = dmd.YRes(); unsigned char* pDestImage = pDepthTexBuf; const XnDepthPixel* pDepth = dmd.Data(); const XnLabel* pLabels = smd.Data(); // Calculate the accumulative histogram memset(g_pDepthHist, 0, MAX_DEPTH*sizeof(float)); for (nY=0; nY<g_nYRes; nY++) { for (nX=0; nX<g_nXRes; nX++) { nValue = *pDepth; if (nValue != 0) { g_pDepthHist[nValue]++; nNumberOfPoints++; } pDepth++; } } for (nIndex=1; nIndex<MAX_DEPTH; nIndex++) { g_pDepthHist[nIndex] += g_pDepthHist[nIndex-1]; } if (nNumberOfPoints) { for (nIndex=1; nIndex<MAX_DEPTH; nIndex++) { g_pDepthHist[nIndex] = (unsigned int)(256 * (1.0f - (g_pDepthHist[nIndex] / nNumberOfPoints))); } } XnPoint3D coms[20]; XnUInt32 labels[20] = {0}; for (int i = 0; i < 20; ++i) { coms[i] = xnCreatePoint3D(0,0,0); } pDepth = dmd.Data(); { XnUInt32 nIndex = 0; // Prepare the texture map for (nY=0; nY<g_nYRes; nY++) { for (nX=0; nX < g_nXRes; nX++, nIndex++) { nValue = *pDepth; XnLabel label = *pLabels; XnUInt32 nColorID = label % nColors; if (label == 0) { nColorID = nColors; } if (nValue != 0) { nHistValue = g_pDepthHist[nValue]; pDestImage[0] = nHistValue * Colors[nColorID][0]; pDestImage[1] = nHistValue * Colors[nColorID][1]; pDestImage[2] = nHistValue * Colors[nColorID][2]; if (label < 20 && label > 0) { coms[label].X += nX; coms[label].Y += nY; coms[label].Z += *pDepth; labels[label]++; } } else { pDestImage[0] = 0; pDestImage[1] = 0; pDestImage[2] = 0; } pDepth++; pLabels++; pDestImage+=3; } pDestImage += (texWidth - g_nXRes) *3; } } glBindTexture(GL_TEXTURE_2D, depthTexID); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pDepthTexBuf); // Display the OpenGL texture map glColor4f(0.75,0.75,0.75,1); glEnable(GL_TEXTURE_2D); DrawTexture(dmd.XRes(),dmd.YRes(),0,0); glDisable(GL_TEXTURE_2D); char strLabel[3] = ""; for (int i = 0; i < 20; ++i) { if (labels[i] == 0) continue; coms[i].X /= labels[i]; coms[i].Y /= labels[i]; coms[i].Z /= labels[i]; sprintf(strLabel, "%d", i); glColor4f(1-Colors[i%nColors][0], 1-Colors[i%nColors][1], 1-Colors[i%nColors][2], 1); glRasterPos2i(coms[i].X, coms[i].Y); glPrintString(GLUT_BITMAP_HELVETICA_18, strLabel); } }
void Camera::drawOverlay(){ glPushMatrix(); glTranslatef(position[INDEX_CAM_X], position[INDEX_CAM_Y] - 0.2, position[INDEX_CAM_Z]); glRotatef(-orientation[CAM_YAW] + 90, 0,1,0); glRotatef(-orientation[CAM_PITCH], 1,0,0); arms->drawModel(); glPopMatrix(); if(currentFade > 1 || currentFade < 0){ currentFade = targetFade; }else{ if(targetFade > currentFade){ currentFade += CAM_FADE_SPEED; }else{ currentFade -= CAM_FADE_SPEED; } } /* Switch Draw Mode */ glPushMatrix(); // 1 glDisable(GL_LIGHTING); glEnable(GL_PROJECTION); glPushMatrix(); // 2 glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glOrtho(0, screenAttr[INDEX_SCREEN_WIDTH], screenAttr[INDEX_SCREEN_HEIGHT], 0, -1, 1); glPushMatrix(); // 3 glLoadIdentity(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(0, 0, 0, currentFade); glBegin(GL_QUADS); glVertex2f(0, 0); glVertex2f(screenAttr[INDEX_SCREEN_WIDTH], 0); glVertex2f(screenAttr[INDEX_SCREEN_WIDTH], screenAttr[INDEX_SCREEN_WIDTH]); glVertex2f(0, screenAttr[INDEX_SCREEN_WIDTH]); glEnd(); glDisable(GL_BLEND); if(drawDebug){ glColor3f( 255, 255, 255 ); for(unsigned int w = 0; w < debugText.size(); w++){ glRasterPos2i(10, 20 + (15 * w)); const char* str = debugText[w].c_str(); int len, i; len = (int)strlen(str); for (i = 0; i < len; i++) { glutBitmapCharacter(GLUT_BITMAP_9_BY_15, str[i]); } } debugText.clear(); } glPopMatrix(); // 3 glPopMatrix(); // 2 glEnable(GL_LIGHTING); glPopMatrix(); // 1 std::ostringstream fadeDebug; fadeDebug << "[CAM] Fade = " << currentFade; debugText.push_back(fadeDebug.str()); }
void DrawSVG::draw_zoom() { // size (in pixels) of region of interest const size_t regionSize = 32; // relative size of zoom window size_t zoomFactor = 16; // compute zoom factor---the zoom window should never cover // more than 40% of the framebuffer, horizontally or vertically size_t bufferSize = min( width, height ); if( regionSize*zoomFactor > bufferSize * 0.4) { zoomFactor = (bufferSize * 0.4 )/regionSize; } size_t zoomSize = regionSize * zoomFactor; // adjust the cursor coordinates so that the region of // interest never goes outside the bounds of the framebuffer size_t cX = max( regionSize/2, min( width-regionSize/2-1, (size_t) cursor_x )); size_t cY = max( regionSize/2, min( height-regionSize/2-1, height - (size_t) cursor_y )); // grab pixels from the region of interest vector<unsigned char> windowPixels( 3*regionSize*regionSize ); glReadPixels( cX - regionSize/2, cY - regionSize/2 + 1, // meh regionSize, regionSize, GL_RGB, GL_UNSIGNED_BYTE, &windowPixels[0] ); // upsample by the zoom factor, highlighting pixel boundaries vector<unsigned char> zoomPixels( 3*zoomSize*zoomSize ); unsigned char* wp = &windowPixels[0]; // outer loop over pixels in region of interest for( int y = 0; y < regionSize; y++ ) { int y0 = y*zoomFactor; for( int x = 0; x < regionSize; x++ ) { int x0 = x*zoomFactor; unsigned char* zp = &zoomPixels[ ( x0 + y0*zoomSize )*3 ]; // inner loop over upsampled block for( int j = 0; j < zoomFactor; j++ ) { for( int i = 0; i < zoomFactor; i++ ) { for( int k = 0; k < 3; k++ ) { // highlight pixel boundaries if( i == 0 || j == 0 ) { const float s = .3; zp[k] = (int)( (1.-2.*s)*wp[k] + s*255. ); } else { zp[k] = wp[k]; } } zp += 3; } zp += 3*( zoomSize - zoomFactor ); } wp += 3; } } // copy pixels to the screen using OpenGL glMatrixMode( GL_PROJECTION ); glPushMatrix(); glLoadIdentity(); glOrtho( 0, width, 0, height, 0.01, 1000. ); glMatrixMode( GL_MODELVIEW ); glPushMatrix(); glLoadIdentity(); glTranslated( 0., 0., -1. ); glRasterPos2i( width-zoomSize, height-zoomSize ); glDrawPixels( zoomSize, zoomSize, GL_RGB, GL_UNSIGNED_BYTE, &zoomPixels[0] ); glMatrixMode( GL_PROJECTION ); glPopMatrix(); glMatrixMode( GL_MODELVIEW ); glPopMatrix(); }
void IsoLine::drawGLIsoLineLabels(GRIBOverlayFactory *pof, wxColour text_color, wxColour back_color, PlugIn_ViewPort *vp, int density, int first, double coef) { std::list<Segment *>::iterator it; int nb = first; wxString label; label.Printf(_T("%d"), (int)(value*coef+0.5)); int w, h; wxPen penText(text_color); wxBrush backBrush(back_color); int label_offset = 10; if(!m_imageLabel.IsOk()) { wxBitmap bm(100,100); // big enough wxMemoryDC mdc(bm); mdc.Clear(); mdc.GetTextExtent(label, &w, &h); mdc.SetPen(penText); mdc.SetBrush(backBrush); mdc.SetTextForeground(text_color); mdc.SetTextBackground(back_color); int xd = 0; int yd = 0; // mdc.DrawRoundedRectangle(xd, yd, w+(label_offset * 2), h, -.25); mdc.DrawRectangle(xd, yd, w+(label_offset * 2), h+2); mdc.DrawText(label, label_offset/2 + xd, yd-1); mdc.SelectObject(wxNullBitmap); wxBitmap sub_BMLabel = bm.GetSubBitmap(wxRect(0,0,w+(label_offset * 2), h+2)); m_imageLabel = sub_BMLabel.ConvertToImage(); } //--------------------------------------------------------- // Ecrit les labels //--------------------------------------------------------- for (it=trace.begin(); it!=trace.end(); it++,nb++) { if (nb % density == 0) { Segment *seg = *it; // if(vp->vpBBox.PointInBox((seg->px1 + seg->px2)/2., (seg->py1 + seg->py2)/2., 0.)) { int w = m_imageLabel.GetWidth(); int h = m_imageLabel.GetHeight(); wxPoint ab; GetCanvasPixLL(vp, &ab, seg->py1, seg->px1); wxPoint cd; GetCanvasPixLL(vp, &cd, seg->py1, seg->px1); int xd = (ab.x + cd.x-(w+label_offset * 2))/2; int yd = (ab.y + cd.y - h)/2; glRasterPos2i(xd, yd); glPixelZoom(1, -1); /* draw data from top to bottom */ glDrawPixels(w, h, GL_RGB, GL_UNSIGNED_BYTE, m_imageLabel.GetData()); glPixelZoom(1, 1); } } } }
void draw(void) { glRasterPos2i(0, 0); glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); }
void drawDeath(Player &player) { glClearColor(0.0, 0.0, 0.0, 1.0); glColor3f(1.0, 1.0, 1.0); glRasterPos2i(50, 50); if (playerSpriteIdle == NULL) { GLuint tex_2d = SOIL_load_OGL_texture ( "marioidle.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT ); playerSpriteIdle = new Sprite(); playerSpriteIdle->initializeSprite(tex_2d, 0, 0, 15.0f, 20.0f); if( 0 == tex_2d ) { printf( "SOIL loading error: '%s'\n", SOIL_last_result() ); } } glEnable(GL_TEXTURE_2D); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBindTexture(GL_TEXTURE_2D, playerSpriteIdle->getID()); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glColor3f(1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(245, 177); glTexCoord2f(0.0f, 1.0f); glVertex2f(245, 157); glTexCoord2f(1.0f, 1.0f); glVertex2f(230, 157); glTexCoord2f(1.0f, 0.0f); glVertex2f(230, 177); glEnd(); glDisable(GL_TEXTURE_2D); glClear(GL_DEPTH_BUFFER_BIT); std::stringstream ss; ss.str(""); glRasterPos2i(255, 175); ss << "x" << player.getLives(); std::string s = ss.str(); void * font = GLUT_BITMAP_TIMES_ROMAN_24; for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } }
void drawUI(Player &player) { glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, 1024, 768, 0, 0, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glColor3f(1.0, 1.0, 1.0); glRasterPos2i(50, 50); std::stringstream ss; ss << "MARIO"; std::string s = ss.str(); void * font = GLUT_BITMAP_TIMES_ROMAN_24; for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } ss.str(""); glRasterPos2i(900, 50); ss << "WORLD"; s = ss.str(); for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } ss.str(""); glRasterPos2i(50, 75); ss << player.getPlayerScore(); s = ss.str(); for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } if (playerSpriteIdle == NULL) { GLuint tex_2d = SOIL_load_OGL_texture ( "marioidle.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT ); playerSpriteIdle = new Sprite(); playerSpriteIdle->initializeSprite(tex_2d, 0, 0, 15.0f, 20.0f); if( 0 == tex_2d ) { printf( "SOIL loading error: '%s'\n", SOIL_last_result() ); } } glEnable(GL_TEXTURE_2D); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBindTexture(GL_TEXTURE_2D, playerSpriteIdle->getID()); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glColor3f(1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(290, 77); glTexCoord2f(0.0f, 1.0f); glVertex2f(290, 57); glTexCoord2f(1.0f, 1.0f); glVertex2f(275, 57); glTexCoord2f(1.0f, 0.0f); glVertex2f(275, 77); glEnd(); glDisable(GL_TEXTURE_2D); glClear(GL_DEPTH_BUFFER_BIT); ss.str(""); glRasterPos2i(300, 75); ss << "x" << player.getLives(); s = ss.str(); for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } ss.str(""); glRasterPos2i(924, 75); ss << "1-1"; s = ss.str(); for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); }
/* virtual */ bool hwRenderEffect::execute() { MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer(); if (!pRenderer) return false; const MString & backEndStr = pRenderer->backEndString(); unsigned int width = 0, height = 0; MStatus stat = pRenderer->getBufferSize( backEndStr, width, height ); if (width <= 0 || height <= 0) return false; unsigned int exposureNum; unsigned int totalExposureCount; pRenderer->getCurrentExposureNumber( backEndStr, exposureNum ); pRenderer->getTotalExposureCount( backEndStr, totalExposureCount ); // Perform some post-rendering. Invert the image. bool xxxx = true; if ( xxxx && mLocation == MHardwareRenderer::kPostRendering ) { cout<<"Call EXP["<<exposureNum<<"/"<<totalExposureCount <<"] hwRenderEffect::execute("<<width<<", "<<height <<") -- "<<fName.asChar()<<endl; MHardwareRenderer::BufferPixelFormat colFmt; stat = pRenderer->getColorBufferPixelFormat( backEndStr, colFmt ); void *pixels = 0; unsigned int data_type = GL_UNSIGNED_BYTE; unsigned int format = GL_RGBA; unsigned int totalSize = width*height*4; if (totalSize == 0) return false; if (colFmt == MHardwareRenderer::kRGBA_Fix8) { data_type = GL_UNSIGNED_BYTE; format = GL_RGBA; pixels = new unsigned char[totalSize]; } #ifdef _SUPPORT_16_FLOAT_ else if (MHardwareRenderer::kRGBA_Float16) { data_type = GL_HALF_FLOAT; format = GL_RGBA; pixels = new half[totalSize]; } #endif glPushAttrib(GL_ALL_ATTRIB_BITS); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glPixelZoom( 1.0f, 1.0f ); glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(0, 0, width, height, format, data_type, pixels); unsigned char *pixelPtr = (unsigned char*)pixels; if (pixelPtr) { unsigned int numPixels = width * height; for (unsigned int i=0; i < numPixels; i++) { *pixelPtr = (255 - *pixelPtr); pixelPtr++; *pixelPtr = (255 - *pixelPtr); pixelPtr++; *pixelPtr = (255 - *pixelPtr); pixelPtr++; *pixelPtr = 255; pixelPtr++; } } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glRasterPos2i( -1, -1 ); // We only want to clobber RGB. Leave alpha as is. glColorMask( 1, 1, 1, 0 ); // For orthographic views, we need to make sure that depth // test is disabled, otherwise the pixels will not draw. glDisable(GL_DEPTH_TEST); glDrawPixels(width, height, format, data_type, pixels); if (pixels) { if (colFmt == MHardwareRenderer::kRGBA_Fix8) { unsigned char *pixelPtr2 = (unsigned char*)pixels; delete[] pixelPtr2; } #ifdef _SUPPORT_16_FLOAT_ else { half pixelPtr2 = (half*)pixels; delete[] pixelPtr2; } #endif } glPopAttrib(); } else { // Perform some pre-rendering, pre-exposure. Draw coloured // triangles. if ( (mLocation == MHardwareRenderer::kPreRendering ) || ( mLocation == MHardwareRenderer::kPreExposure) ) { cout<<"Call EXP["<<exposureNum<<"/"<<totalExposureCount <<"] hwRenderEffect::execute("<<width<<", "<<height <<") -- "<<fName.asChar()<<endl; glPushAttrib(GL_ALL_ATTRIB_BITS); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glShadeModel(GL_SMOOTH); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ZERO); glColorMask( 1, 1, 1, 0 ); glBegin(GL_QUADS); glColor4f(1.0f,1.0f,1.0f,0.5f); glVertex3f( -1.0f, 1.0f, 0.0f); glColor4f(0.0f,1.0f,1.0f,0.5f); glVertex3f( 0.0f, 1.0f, 0.0f); glColor4f(0.0f,1.0f,1.0f,0.5f); glVertex3f(-1.0f,-1.0f, 0.0f); glColor4f(1.0f,0.0f,1.0f,0.5f); glVertex3f( 1.0f,-1.0f, 0.0f); glEnd(); glEnable(GL_DEPTH_TEST); glDisable(GL_BLEND); glPopAttrib(); } // Do some post exposure. Nothing for now... else if ( mLocation == MHardwareRenderer::kPostExposure ) { cout<<"Call EXP["<<exposureNum<<"/"<<totalExposureCount <<"] hwRenderEffect::execute("<<width<<", "<<height<<") -- POST-EXPOSURE"<<endl; } } return true; }
/* Display 12 point white Helvetica font to screen */ void Text::textToScreenMedium(float x, float y, unsigned char* text) { glColor4f(this->r, this->g, this->b, 1.0f); glRasterPos2i(x, y); glutBitmapString(GLUT_BITMAP_HELVETICA_12, text); }
void RenderViewWidget::draw(){ //Setup shaders Assert(hdrShaderIdx >= 0 && ((size_t)hdrShaderIdx) < hdrFragShaders.size()); // QGLFormat format; // QGLContext context(format); // QGLShaderProgram program(&context); QGLShaderProgram program(QGLContext::currentContext()); program.addShader( hdrFragShaders[hdrShaderIdx] ); program.link(); program.bind(); //Draw QPainter p(this); saveGLState(); glDisable(GL_LIGHTING); glDisable(GL_DEPTH_TEST); //Texture setup glBindTexture(GL_TEXTURE_2D, texture_fbo->texture() ); glEnable(GL_TEXTURE_2D); glEnable(GL_MULTISAMPLE); //TODO: HERE IS WHERE WE SHOULD GET THE IMAGE BUFFER int wim = 128; int him = 128; HDRImage* im = new HDRImage(wim,him); makeIm(im); float* buf = im->getPixelBuf(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, //Internal format wim, him, 0, GL_RGB, GL_FLOAT, (void*) buf ); delete im; //Full screen quad code from here: //http://www.michimichbeck.de/wordpress/tag/full-screen-quad/ const float ww = 1; const float hh = 1; const float z = -1; glRasterPos2i(0,0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1,1,-1,1, 1.0, 40.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glViewport(0,0,w,h); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBegin (GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex3f(-ww, -hh, z); glTexCoord2f(0.0f, 1.0f); glVertex3f(ww, -hh, z); glTexCoord2f(1.0f, 1.0f); glVertex3f(ww, hh , z); glTexCoord2f(0.0f, 1.0f); glVertex3f(-ww, hh, z ); glEnd(); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); restoreGLState(); }
void DrawText2D(uint x, uint y, const char* str) { glRasterPos2i(x,y); while(*str) glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12,*str++); }
void ZombieGFX::DrawFinalScore(int nScore) { // Your final score is: // white text glColor3f(1.0, 1.0, 1.0); // The city is lost! Click to play again! glRasterPos2i(90,100); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'Y'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'o'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'u'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'r'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ' '); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'f'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'i'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'n'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'a'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'l'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ' '); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 's'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'c'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'o'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'r'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'e'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ' '); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 'i'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, 's'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ':'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ' '); // extract digits of the score and print them int nDigits[4]; nDigits[0] = nScore/1000; nDigits[1] = (nScore/100)%10; nDigits[2] = (nScore/10)%10; nDigits[3] = nScore % 10; if (nScore < 0) glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '-'); for (int i = 0; i < 4; i++) { switch(abs(nDigits[i])) { case 0: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '0'); break; case 1: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '1'); break; case 2: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '2'); break; case 3: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '3'); break; case 4: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '4'); break; case 5: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '5'); break; case 6: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '6'); break; case 7: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '7'); break; case 8: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '8'); break; case 9: glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, '9'); break; } } }
static void drawscene(void) { static char frbuf[80] = ""; dojoy(); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); if (usetex) glEnable(GL_TEXTURE_2D); else glDisable(GL_TEXTURE_2D); if (fog) glEnable(GL_FOG); else glDisable(GL_FOG); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); calcposobs(); gluLookAt(obs[0], obs[1], obs[2], obs[0] + dir[0], obs[1] + dir[1], obs[2] + dir[2], 0.0, 1.0, 0.0); drawterrain(); glPopMatrix(); glDisable(GL_TEXTURE_2D); glDisable(GL_DEPTH_TEST); glDisable(GL_FOG); glShadeModel(GL_FLAT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glColor3f(1.0, 0.0, 0.0); glRasterPos2i(10, 10); printstring(GLUT_BITMAP_HELVETICA_18, frbuf); glRasterPos2i(350, 470); printstring(GLUT_BITMAP_HELVETICA_10, "Terrain V1.2 Written by David Bucciarelli ([email protected])"); glRasterPos2i(434, 457); printstring(GLUT_BITMAP_HELVETICA_10, "Based on a Mickael's demo ([email protected])"); if (help) printhelp(); reshape(scrwidth, scrheight); glutSwapBuffers(); Frames++; { GLint t = glutGet(GLUT_ELAPSED_TIME); if (t - T0 >= 2000) { GLfloat seconds = (t - T0) / 1000.0; GLfloat fps = Frames / seconds; sprintf(frbuf, "Frame rate: %f", fps); printf("%s\n", frbuf); fflush(stdout); T0 = t; Frames = 0; } } }
static void draw(void) { static int count=0; static char frbuf[80]; float fr; dojoy(); glEnable(GL_DEPTH_TEST); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); if(usetex) glEnable(GL_TEXTURE_2D); else glDisable(GL_TEXTURE_2D); if(fog) glEnable(GL_FOG); else glDisable(GL_FOG); glEnable(GL_LIGHTING); glShadeModel(GL_SMOOTH); glPushMatrix(); calcposobs(); gluLookAt(obs[0],obs[1],obs[2], obs[0]+dir[0],obs[1]+dir[1],obs[2]+dir[2], 0.0,0.0,1.0); drawlight1(); glCallList(basedlist); drawteapot(); drawlight2(); glPopMatrix(); if((count % FRAME)==0) { fr=gettime(); sprintf(frbuf,"Frame rate: %f",FRAME/fr); } glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); glDisable(GL_DEPTH_TEST); glDisable(GL_FOG); glShadeModel(GL_FLAT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-0.5,639.5,-0.5,479.5,-1.0,1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glColor3f(1.0,0.0,0.0); glRasterPos2i(10,10); printstring(GLUT_BITMAP_HELVETICA_18,frbuf); glRasterPos2i(350,470); printstring(GLUT_BITMAP_HELVETICA_10,"Teapot V1.2 Written by David Bucciarelli ([email protected])"); if(help) printhelp(); reshape(WIDTH,HEIGHT); glutSwapBuffers(); count++; }
static void PrintHelpAndSettings() { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(0.f, 0.f, 0.f, 0.5f); glRecti(10, 20, session->film->GetWidth() - 10, session->film->GetHeight() - 20); glDisable(GL_BLEND); glColor3f(1.f, 1.f, 1.f); int fontOffset = session->film->GetHeight() - 20 - 20; glRasterPos2i((session->film->GetWidth() - glutBitmapLength(GLUT_BITMAP_9_BY_15, (unsigned char *)"Help & Settings & Devices")) / 2, fontOffset); PrintString(GLUT_BITMAP_9_BY_15, "Help & Settings & Devices"); // Help fontOffset -= 25; PrintHelpString(15, fontOffset, "h", "toggle Help"); fontOffset -= 15; PrintHelpString(15, fontOffset, "arrow Keys or mouse X/Y + mouse button 0", "rotate camera"); fontOffset -= 15; PrintHelpString(15, fontOffset, "a, s, d, w or mouse X/Y + mouse button 1", "move camera"); fontOffset -= 15; PrintHelpString(15, fontOffset, "p", "save image.png (or to image.filename property value)"); fontOffset -= 15; PrintHelpString(15, fontOffset, "t", "toggle tonemapping"); PrintHelpString(320, fontOffset, "n, m", "dec./inc. the screen refresh"); fontOffset -= 15; PrintHelpString(15, fontOffset, "i", "switch sampler"); fontOffset -= 15; PrintHelpString(15, fontOffset, "1", "OpenCL path tracing"); PrintHelpString(320, fontOffset, "2", "CPU light tracing"); fontOffset -= 15; PrintHelpString(15, fontOffset, "3", "CPU path tracing"); PrintHelpString(320, fontOffset, "4", "CPU bidir. path tracing"); fontOffset -= 15; PrintHelpString(15, fontOffset, "5", "Hybrid bidir. path tracing"); PrintHelpString(320, fontOffset, "6", "Hybrid combinatorial bidir. path tracing"); fontOffset -= 15; PrintHelpString(15, fontOffset, "7", "CPU bidir. VM path tracing"); fontOffset -= 15; #if defined(WIN32) PrintHelpString(15, fontOffset, "o", "windows always on top"); fontOffset -= 15; #endif // Settings char buf[512]; glColor3f(0.5f, 1.0f, 0.f); fontOffset -= 15; glRasterPos2i(15, fontOffset); PrintString(GLUT_BITMAP_8_BY_13, "Settings:"); fontOffset -= 15; glRasterPos2i(20, fontOffset); sprintf(buf, "[Rendering time %dsecs][Screen refresh %dms]", int(session->renderEngine->GetRenderingTime()), session->renderConfig->GetScreenRefreshInterval()); PrintString(GLUT_BITMAP_8_BY_13, buf); fontOffset -= 15; glRasterPos2i(20, fontOffset); sprintf(buf, "[Render engine %s][Sampler %s][Tone mapping %s]", RenderEngine::RenderEngineType2String(session->renderEngine->GetEngineType()).c_str(), session->renderConfig->cfg.GetString("sampler.type", "RANDOM").c_str(), (session->film->GetToneMapParams()->GetType() == TONEMAP_LINEAR) ? "LINEAR" : "REINHARD02"); PrintString(GLUT_BITMAP_8_BY_13, buf); fontOffset -= 15; glRasterPos2i(20, fontOffset); // Intersection devices const vector<IntersectionDevice *> &idevices = session->renderEngine->GetIntersectionDevices(); double minPerf = idevices[0]->GetTotalPerformance(); double totalPerf = idevices[0]->GetTotalPerformance(); for (size_t i = 1; i < idevices.size(); ++i) { minPerf = min(minPerf, idevices[i]->GetTotalPerformance()); totalPerf += idevices[i]->GetTotalPerformance(); } glColor3f(1.0f, 0.5f, 0.f); int offset = 45; size_t deviceCount = idevices.size(); char buff[512]; for (size_t i = 0; i < deviceCount; ++i) { sprintf(buff, "[%s][Rays/sec %dK (%dK + %dK)][Prf Idx %.2f][Wrkld %.1f%%][Mem %dM/%dM]", idevices[i]->GetName().c_str(), int(idevices[i]->GetTotalPerformance() / 1000.0), int(idevices[i]->GetSerialPerformance() / 1000.0), int(idevices[i]->GetDataParallelPerformance() / 1000.0), idevices[i]->GetTotalPerformance() / minPerf, 100.0 * idevices[i]->GetTotalPerformance() / totalPerf, int(idevices[i]->GetUsedMemory() / (1024 * 1024)), int(idevices[i]->GetMaxMemory() / (1024 * 1024))); glRasterPos2i(20, offset); PrintString(GLUT_BITMAP_8_BY_13, buff); offset += 15; } glRasterPos2i(15, offset); PrintString(GLUT_BITMAP_9_BY_15, "Rendering devices:"); }
void drawCharacter(int x, int y, char ch, COLOR color) { glColor3f( color.red, color.green, color.blue ); glRasterPos2i(x, y); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, ch); }
void filemenu(int mode) { getstats(mode); if (button(100,100,170,120,"OPTIMIZE",9,13,base2,false,mode)==DDgui_LeftClick && mode!=DD_AfterCheck) { optimizeproject(); waitleftbutton=true; } if (button(100,121,170,141,"TextureO",9,13,base2,false,mode)==DDgui_LeftClick && mode!=DD_AfterCheck) { savetextureusefile(); waitleftbutton=true; } if (mode==DD_Draw) { glColor4f(buttontextlit); rectangle(661,120,775,264); } if (mode==DD_Check) if (leftclickinwindow(661,121,774,263) && mouseinwindow(661,121,774,260)) fscnselected=min(fscnbarpos+(my-121) / 10,filenum(prjlist)-1); if ((mode ==DD_Check) && mouseinwindow(661,121,774,263)) fscnbarpos-=wheel*4; scroller(775,120,790,264,15,15,filenum(prjlist),14,fscnbarpos,mode); if (mode==DD_Draw) { pf = prjlist; for (x=1;x<=fscnbarpos;x++) pf=pf->next; for (x=0;x<=13;x++) { if (pf!=NULL) { if (fscnbarpos+x==fscnselected) glColor4f(col4); else glColor4f(buttontextlit); glRasterPos2i(665,130+x*10); strcpy(st,pf->filedata.cFileName); glPrint(st,base2,18); pf=pf->next; } } glColor4f(buttontextlit); sprintf(s,"%d PROJECTS.",filenum(prjlist)); glRasterPos2i(683,277); glPrint(s,base2); } glColor4f(1,1,1,1); if ((button(686,283,771,299,texbutton1,0,96.0/256.0,85.0/256.0,112.0/256.0,false,mode) == DDgui_LeftClick) && (mode!=DD_AfterCheck)) { pf = prjlist; for (x=1;x<=fscnselected;x++) pf=pf->next; //sprintf(s,"%s%s",scenedir,pf->filedata.cFileName); memset(lastfilename,0,256); memcpy(lastfilename,pf->filedata.cFileName,strlen(pf->filedata.cFileName)-4); sprintf(s,"%s%s",projectdir,pf->filedata.cFileName); //loadaDDictscene(*actualscene,NULL,s,true,true,true,true,true); LoadProject(s); modellviews[3].cam=actualscene->editview; modellviews[3].cam2=actualscene->editview; tTexture *tex=texturelist; while ((tex!=NULL) && (tex->number!=selectedtexture)) tex=tex->next; memcpy(generatedtexture.commands,tex->commands,sizeof(generatedtexture.commands)); memcpy(generatedtexture.texts,tex->texts,sizeof(generatedtexture.texts)); generatedtexture.commandnum=tex->commandnum; //memcpy(generatedtexture.layers,tex->layers,sizeof(generatedtexture.layers)); for (y=0;y<=3;y++) { glBindTexture(GL_TEXTURE_2D, texlayers[y]); glTexImage2D(GL_TEXTURE_2D,0,3,256,256,0,GL_RGBA,GL_UNSIGNED_BYTE,generatedtexture.layers[y]); } if (materiallist!=NULL) { matselected=0; material *mat=materiallist; for (x=1;x<=matselected;x++) mat=mat->next; mattexture=mat->handle; } waitleftbutton=true; } if (button(685,300,770,316,texbutton1,0,144.0/256.0,85.0/256.0,160.0/256.0,false,mode) == DDgui_LeftClick) { char *ss=readline("Enter Filename (.scn not needed)",210,0,base2,lastfilename); if (ss!="") { //sprintf(s,"%s%s.scn",scenedir,ss); //saveaDDictscene(*actualscene,NULL,s,scntexturesave, scncamerasave, scnselectionsave, scnlightsave, scnobjectsave); memset(lastfilename,0,256); memcpy(lastfilename,ss,strlen(ss)); sprintf(s,"%s%s.64k",projectdir,ss); SaveProject(s); } } if (button(685,317,770,333,texbutton1,0,160.0/256.0,85.0/256.0,176.0/256.0,false,mode) == DDgui_LeftClick) { char *ss=readline("Enter Filename (.scn not needed)",210,0,base2,""); if (ss!="") { sprintf(s,"%s%s.m64",minimaldir,ss); //SaveMinimalScene(*actualscene,NULL,s); saveminimalproject(s,2); } } /*RadioButton(681,341,scntexturesave,"TEXTURES",mode); RadioButton(681,355,scncamerasave,"CAMERAS",mode); RadioButton(681,369,scnselectionsave,"SELECTIONS",mode); RadioButton(681,383,scnlightsave,"LIGHTS",mode); RadioButton(681,397,scnobjectsave,"OBJECTS",mode);*/ }
void Gestures::DrawSkeleton( const xn::DepthMetaData& dmd, const xn::SceneMetaData& smd ) { char strLabel[50] = ""; XnUserID aUsers[15]; XnUInt16 nUsers = 15; m_UserGenerator.GetUsers(aUsers, nUsers); for (int i = 0; i < nUsers; ++i) { if (m_bPrintID) { XnPoint3D com; m_UserGenerator.GetCoM(aUsers[i], com); m_DepthGenerator.ConvertRealWorldToProjective(1, &com, &com); xnOSMemSet(strLabel, 0, sizeof(strLabel)); if (!m_bPrintState) { // Tracking sprintf(strLabel, "%d", aUsers[i]); } else if (m_UserGenerator.GetSkeletonCap().IsTracking(aUsers[i])) { // Tracking sprintf(strLabel, "%d - Tracking", aUsers[i]); } else if (m_UserGenerator.GetSkeletonCap().IsCalibrating(aUsers[i])) { // Calibrating sprintf(strLabel, "%d - Calibrating...", aUsers[i]); } else { // Nothing sprintf(strLabel, "%d - Looking for pose", aUsers[i]); } glColor4f(1-Colors[i%m_nColors][0], 1-Colors[i%m_nColors][1], 1-Colors[i%m_nColors][2], 1); glRasterPos2i(com.X, com.Y); glPrintString(GLUT_BITMAP_HELVETICA_18, strLabel); } if (m_bDrawSkeleton && m_UserGenerator.GetSkeletonCap().IsTracking(aUsers[i])) { glBegin(GL_LINES); glColor4f(1-Colors[aUsers[i]%m_nColors][0], 1-Colors[aUsers[i]%m_nColors][1], 1-Colors[aUsers[i]%m_nColors][2], 1); DrawLimb(aUsers[i], XN_SKEL_HEAD, XN_SKEL_NECK); DrawLimb(aUsers[i], XN_SKEL_NECK, XN_SKEL_LEFT_SHOULDER); DrawLimb(aUsers[i], XN_SKEL_LEFT_SHOULDER, XN_SKEL_LEFT_ELBOW); DrawLimb(aUsers[i], XN_SKEL_LEFT_ELBOW, XN_SKEL_LEFT_HAND); DrawLimb(aUsers[i], XN_SKEL_NECK, XN_SKEL_RIGHT_SHOULDER); DrawLimb(aUsers[i], XN_SKEL_RIGHT_SHOULDER, XN_SKEL_RIGHT_ELBOW); DrawLimb(aUsers[i], XN_SKEL_RIGHT_ELBOW, XN_SKEL_RIGHT_HAND); DrawLimb(aUsers[i], XN_SKEL_LEFT_SHOULDER, XN_SKEL_TORSO); DrawLimb(aUsers[i], XN_SKEL_RIGHT_SHOULDER, XN_SKEL_TORSO); DrawLimb(aUsers[i], XN_SKEL_TORSO, XN_SKEL_LEFT_HIP); DrawLimb(aUsers[i], XN_SKEL_LEFT_HIP, XN_SKEL_LEFT_KNEE); DrawLimb(aUsers[i], XN_SKEL_LEFT_KNEE, XN_SKEL_LEFT_FOOT); DrawLimb(aUsers[i], XN_SKEL_TORSO, XN_SKEL_RIGHT_HIP); DrawLimb(aUsers[i], XN_SKEL_RIGHT_HIP, XN_SKEL_RIGHT_KNEE); DrawLimb(aUsers[i], XN_SKEL_RIGHT_KNEE, XN_SKEL_RIGHT_FOOT); DrawLimb(aUsers[i], XN_SKEL_LEFT_HIP, XN_SKEL_RIGHT_HIP); //DrawOtherStuff( aUsers[i], XN_SKEL_HEAD, XN_SKEL_NECK, XN_SKEL_LEFT_SHOULDER, XN_SKEL_LEFT_ELBOW, // XN_SKEL_LEFT_HAND, XN_SKEL_RIGHT_SHOULDER, XN_SKEL_RIGHT_ELBOW, XN_SKEL_RIGHT_HAND, // XN_SKEL_TORSO, XN_SKEL_LEFT_HIP, XN_SKEL_LEFT_KNEE, XN_SKEL_LEFT_FOOT, // XN_SKEL_RIGHT_HIP, XN_SKEL_RIGHT_KNEE, XN_SKEL_RIGHT_FOOT ); glEnd(); } } }
void drawWin(Player &player) { glEnable(GL_TEXTURE_2D); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Background if (titlegroundSprite == NULL) { GLuint tex_2d = SOIL_load_OGL_texture ( "title.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT ); titlegroundSprite = new Sprite(); titlegroundSprite->initializeSprite(tex_2d, 0, 0, 388.0f, 132.0f); if( 0 == tex_2d ) { printf( "SOIL loading error: '%s'\n", SOIL_last_result() ); } } glBindTexture(GL_TEXTURE_2D, titlegroundSprite->getID()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glColor3f(1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); glTexCoord2f(0.0f, 1.0f); glVertex2f(100.0f, 50.0f); glTexCoord2f(0.0f, 0.0f); glVertex2f(100.0f, 182.0f); glTexCoord2f(1.0f, 0.0f); glVertex2f(388.0f, 182.0f); glTexCoord2f(1.0f, 1.0f); glVertex2f(388.0f, 50.0f); glEnd(); glDisable(GL_TEXTURE_2D); glClear(GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, WIDTH, HEIGHT, 0, 0, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glColor3f(0.0, 0.0, 0.0); glRasterPos2i(175.0f, 200.0f); std::stringstream ss; ss << "PRESS ENTER TO START"; std::string s = ss.str(); void * font = GLUT_BITMAP_TIMES_ROMAN_24; for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } ss.str(""); glRasterPos2i(140.0f, 230.0f); ss << "YOU COLLECTED ALL THREE COINS!"; s = ss.str(); for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } ss.str(""); glRasterPos2i(200.0f, 250.0f); ss << "SCORE: " << player.getPlayerScore(); s = ss.str(); for (std::string::iterator i = s.begin(); i != s.end(); ++i) { char c = *i; glutBitmapCharacter(font, c); } glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); }
PsychError SCREENWaitBlanking(void) { PsychWindowRecordType *windowRecord; int waitFrames, framesWaited; double tvbl, ifi; long screenwidth, screenheight; int vbl_startline, beampos; int scanline, lastline; psych_uint64 vblCount, vblRefCount; CGDirectDisplayID cgDisplayID; GLint read_buffer, draw_buffer; // All subfunctions should have these two lines. PsychPushHelp(useString, synopsisString, seeAlsoString); if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);}; PsychErrorExit(PsychCapNumInputArgs(2)); //The maximum number of inputs PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs // Get the window record from the window record argument and get info from the window record PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord); if(!PsychIsOnscreenWindow(windowRecord)) PsychErrorExitMsg(PsychError_user, "Tried to call 'WaitBlanking' on something else than an onscreen window!"); // Get the number of frames to wait: waitFrames = 0; PsychCopyInIntegerArg(2, FALSE, &waitFrames); // We default to wait at least one interval if no argument supplied: waitFrames = (waitFrames < 1) ? 1 : waitFrames; // Enable this windowRecords framebuffer as current drawingtarget: // This is needed to make sure that Offscreen windows work propely. PsychSetDrawingTarget(windowRecord); // Retrieve display handle for beamposition queries: PsychGetCGDisplayIDFromScreenNumber(&cgDisplayID, windowRecord->screenNumber); // Retrieve final vbl_startline, aka physical height of the display in pixels: PsychGetScreenSize(windowRecord->screenNumber, &screenwidth, &screenheight); vbl_startline = (int) screenheight; // Query duration of a monitor refresh interval: We try to use the measured interval, // but fallback of the nominal value reported by the operating system if necessary: if ((ifi = windowRecord->VideoRefreshInterval)<=0) { if (PsychGetNominalFramerate(windowRecord->screenNumber) > 0) { // Valid nominal framerate returned by OS: Calculate nominal IFI from it. ifi = 1.0 / ((double) PsychGetNominalFramerate(windowRecord->screenNumber)); } else { // No reasonable value available! We fallback to an assumed 60 Hz refresh... ifi = 1.0 / 60.0; } } // Query vblcount to test if this method works correctly: PsychOSGetVBLTimeAndCount(windowRecord, &vblRefCount); // Check if beamposition queries are supported by this OS and working properly: if (-1 != PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber) && windowRecord->VBL_Endline >= 0) { // Beamposition queries supported and fine. We can wait for VBL without bufferswap-tricks: // This is the OS-X way of doing things. We query the rasterbeamposition and compare it // to the known values for the VBL area. If we enter VBL, we take a timestamp and return - // or wait for the next VBL if waitFrames>0 // Query current beamposition when entering WaitBlanking: beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); // Are we in VBL when entering WaitBlanking? If so, we should wait for one additional frame, // because by definition, WaitBlanking should always wait for at least one monitor refresh // interval... if ((beampos<=windowRecord->VBL_Endline) && (beampos>=vbl_startline)) waitFrames++; while(waitFrames > 0) { // Enough time for a sleep? If the beam is far away from VBL area, we try to sleep to // yield some CPU time to other processes in the system -- we are nice citizens ;) beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); while (( ((float)(vbl_startline - beampos)) / (float) windowRecord->VBL_Endline * ifi) > 0.003) { // At least 3 milliseconds left until retrace. We sleep for 1 millisecond. PsychWaitIntervalSeconds(0.001); beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); } // Less than 3 ms away from retrace. Busy-Wait for retrace... lastline = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); beampos = lastline; while ((beampos < vbl_startline) && (beampos >= lastline)) { lastline = beampos; beampos = (long) PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); } // Retrace! Take system timestamp of VBL onset: PsychGetAdjustedPrecisionTimerSeconds(&tvbl); // If this wasn't the last frame to wait, we need to wait for end of retrace before // repeating the loop, because otherwise we would detect the same VBL and skip frames. // If it is the last frame, we skip it and return as quickly as possible to save the // Matlab script some extra Millisecond for drawing... if (waitFrames>1) { beampos = vbl_startline; while ((beampos<=windowRecord->VBL_Endline) && (beampos>=vbl_startline)) { beampos = PsychGetDisplayBeamPosition(cgDisplayID, windowRecord->screenNumber); }; } // Done with this refresh interval... // Decrement remaining number of frames to wait: waitFrames--; } } else if (vblRefCount > 0) { // Display beamposition queries unsupported, but vblank count queries seem to work. Try those. // Should work on Linux and OS/X: while(waitFrames > 0) { vblCount = vblRefCount; // Wait for next vblank counter increment - aka start of next frame (its vblank): while (vblCount == vblRefCount) { // Requery: PsychOSGetVBLTimeAndCount(windowRecord, &vblCount); // Yield at least 100 usecs. This is accurate as this code-path // only executes on OS/X and Linux, never on Windows (as of 01/06/2011): PsychYieldIntervalSeconds(0.000100); } vblRefCount = vblCount; // Done with this refresh interval... // Decrement remaining number of frames to wait: waitFrames--; } } else { // Other methods unsupported. We use the doublebuffer swap method of waiting for retrace. // // Working principle: On each frame, we first copy the content of the (user visible) frontbuffer into the backbuffer. // Then we ask the OS to perform a front-backbuffer swap on next vertical retrace and go to sleep via glFinish() et al. // until the OS signals swap-completion. This way PTB's/Matlabs execution will stall until VBL, when swap happens and // we get woken up. We repeat this procedure 'waitFrames' times, then we take a high precision timestamp and exit the // Waitblanking loop. As backbuffer and frontbuffer are identical (due to the copy) at swap time, the visual display // won't change at all for the subject. // This method should work reliably, but it has one drawback: A random wakeup delay (scheduling jitter) is added after // retrace has been entered, so Waitblanking returns only after the beam has left retrace state on older hardware. // This means a bit less time (1 ms?) for stimulus drawing on Windows than on OS-X where Waitblanking returns faster. // Child protection: if (windowRecord->windowType != kPsychDoubleBufferOnscreen) { PsychErrorExitMsg(PsychError_internal, "WaitBlanking tried to perform swap-waiting on a single buffered window!"); } // Setup buffers for front->back copy op: // Backup old read- writebuffer assignments: glGetIntegerv(GL_READ_BUFFER, &read_buffer); glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer); // Set read- and writebuffer properly: glReadBuffer(GL_FRONT); glDrawBuffer(GL_BACK); // Reset viewport to full-screen default: glViewport(0, 0, screenwidth, screenheight); glScissor(0, 0, screenwidth, screenheight); // Reset color buffer writemask to "All enabled": glColorMask(TRUE, TRUE, TRUE, TRUE); glDisable(GL_BLEND); glPixelZoom(1,1); // Disable draw shader: PsychSetShader(windowRecord, 0); // Swap-Waiting loop for 'waitFrames' frames: while(waitFrames > 0) { // Copy current content of front buffer into backbuffer: glRasterPos2i(0, screenheight); glCopyPixels(0, 0, screenwidth, screenheight, GL_COLOR); // Ok, front- and backbuffer are now identical, so a bufferswap // will be a visual no-op. // Enable beamsyncing of bufferswaps to VBL: PsychOSSetVBLSyncLevel(windowRecord, 1); // Trigger bufferswap in sync with retrace: PsychOSFlipWindowBuffers(windowRecord); // Wait for swap-completion, aka beginning of VBL: glColor4f(0,0,0,0); glBegin(GL_POINTS); glVertex2i(10,10); glEnd(); glFinish(); // VBL happened - Take system timestamp: PsychGetAdjustedPrecisionTimerSeconds(&tvbl); // This code-chunk is an alternate way of syncing, only used for debugging: if (false) { // Disable beamsyncing of bufferswaps to VBL: PsychOSSetVBLSyncLevel(windowRecord, 0); // Swap buffers immediately without vsync: PsychOSFlipWindowBuffers(windowRecord); } // Decrement remaining number of frames to wait: waitFrames--; } // Do it again... // Enable beamsyncing of bufferswaps to VBL: PsychOSSetVBLSyncLevel(windowRecord, 1); // Restore assignment of read- writebuffers and such: glEnable(GL_BLEND); glReadBuffer(read_buffer); glDrawBuffer(draw_buffer); // Done with Windows waitblanking... } // Compute number of frames waited: It is timestamp of return of this waitblanking minus // timestamp of return of last waitblanking, divided by duration of a monitor refresh // interval, mathematically rounded to an integral number: framesWaited = (int) (((tvbl - windowRecord->time_at_last_vbl) / ifi) + 0.5f); // Update timestamp for next invocation of Waitblanking: windowRecord->time_at_last_vbl = tvbl; // Return optional number of frames waited: PsychCopyOutDoubleArg(1, FALSE, (double) framesWaited); // Done. return(PsychError_none); }
void OriginalView::draw() { if(!valid()) { glClearColor(0.7f, 0.7f, 0.7f, 1.0); // We're only using 2-D, so turn off depth glDisable( GL_DEPTH_TEST ); // Tell openGL to read from the front buffer when capturing // out paint strokes glReadBuffer( GL_FRONT ); ortho(); } glClear( GL_COLOR_BUFFER_BIT ); if ( m_pDoc->m_ucBitmap ) { // note that both OpenGL pixel storage and the Windows BMP format // store pixels left-to-right, BOTTOM-to-TOP!! thus all the fiddling // around with startrow. m_nWindowWidth=w(); m_nWindowHeight=h(); int drawWidth, drawHeight; GLvoid* bitstart; // we are not using a scrollable window, so ignore it Point scrollpos; // = GetScrollPosition(); scrollpos.x=scrollpos.y=0; drawWidth = min( m_nWindowWidth, m_pDoc->m_nWidth ); drawHeight = min( m_nWindowHeight, m_pDoc->m_nHeight ); int startrow = m_pDoc->m_nHeight - (scrollpos.y + drawHeight); if ( startrow < 0 ) startrow = 0; bitstart = m_pDoc->m_ucBitmap + 3 * ((m_pDoc->m_nWidth * startrow) + scrollpos.x); // just copy image to GLwindow conceptually glRasterPos2i( 0, m_nWindowHeight - drawHeight ); glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); glPixelStorei( GL_UNPACK_ROW_LENGTH, m_pDoc->m_nWidth ); glDrawBuffer( GL_BACK ); glDrawPixels( drawWidth, drawHeight, GL_RGB, GL_UNSIGNED_BYTE, bitstart ); glPointSize(5); glBegin(GL_POINTS); glColor3f(1, 0, 0); glVertex2d(m_nCursor.x - 9, m_nWindowHeight - m_nCursor.y - 1); glEnd(); } glFlush(); }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLint i, j; GLuint width = 16, height = 16; GLint x = 12, y = 12; GLfloat buf[IMAGE_WIDTH][IMAGE_HEIGHT]; GLfloat depth_val = 0.75, stencil_val = 2.0; GLfloat green[4] = {0.0, 1.0, 0.0, 0.0}; bool pass = true; glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); glColor4fv(green); piglit_draw_rect(0, 0, width, height); glRasterPos2i(x, y); glCopyPixels(0, 0, width, height, GL_COLOR); pass = pass && piglit_probe_rect_rgba(x, y, width, height, green); /* Initialize depth data */ for (i = 0; i < IMAGE_HEIGHT; i++) { for(j = 0; j < IMAGE_WIDTH; j++) buf[i][j] = depth_val; } glClearDepth(0.0); glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_ALWAYS); glRasterPos2i(0, 0); glDrawPixels(width, height, GL_DEPTH_COMPONENT, GL_FLOAT, buf); glRasterPos2i(x, y); glCopyPixels(0, 0, width, height, GL_DEPTH); pass = piglit_probe_rect_depth(x, y, width, height, depth_val) && pass; /* Initialize stencil data */ for (i = 0; i < IMAGE_HEIGHT; i++) { for(j = 0; j < IMAGE_WIDTH; j++) buf[i][j] = stencil_val; } glClearStencil(0.0); glClear(GL_STENCIL_BUFFER_BIT); glRasterPos2i(0, 0); glDrawPixels(width, height, GL_STENCIL_INDEX, GL_FLOAT, buf); glRasterPos2i(x, y); glCopyPixels(0, 0, width, height, GL_STENCIL); pass = piglit_probe_rect_stencil(x, y, width, height, stencil_val) && pass; return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
//----------------------------------------------------------------------------- // Name: Render() // Desc: Draws the scene //----------------------------------------------------------------------------- void Render() { glClearColor(0.0F, 0.0F, 0.0F, 1.0F); glClearDepth(1.0F); //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT); //glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glShadeModel(GL_SMOOTH); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //gluLookAt(0, 0, 1, 0, 0, -5, 0, 1, 0); //glTranslatef(0.0f, 0.0f, -0.1f); glMatrixMode(GL_PROJECTION); glLoadIdentity(); //gluPerspective(90.0f, 1.0, 0.1f, 100.0f); glFrustum(-1, 1, -1, 1, 0.95, 10); /*//glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //glTranslatef(0.0f, 0.0f,-4.0f); gluLookAt(0, 0, 0, 0, 0, -5, 0, 1, 0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f, 1.0f, 0.1f, 100.0f);*/ /*glBindBuffer(GL_ARRAY_BUFFER, BufferName[COLOR_OBJECT]); glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[POSITION_OBJECT]); glVertexPointer(2, GL_FLOAT, 0, 0); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glDrawArrays(GL_TRIANGLES, 0, VertexCount); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ARRAY_BUFFER, 0);*/ //AE::uint strideInBytes = 11; AE::uint strideInBytes = 15; AE::uint sizeofFloat = sizeof(float); AE::uint sizeOfFloatTimesTwo = sizeofFloat * 2; AE::uint sizeOfFloatTimesThree = sizeofFloat * 3; glBindBuffer(GL_ARRAY_BUFFER, bufferId); //glVertexPointer(2, GL_FLOAT, strideInBytes, AE_GL_BUFFER_OFFSET(0)); glVertexPointer(3, GL_FLOAT, strideInBytes, AE_GL_BUFFER_OFFSET(0)); //glColorPointer(3, GL_UNSIGNED_BYTE, strideInBytes, AE_GL_BUFFER_OFFSET(sizeOfFloatTimesTwo)); glColorPointer(3, GL_UNSIGNED_BYTE, strideInBytes, AE_GL_BUFFER_OFFSET(sizeOfFloatTimesThree)); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferId); size_t error = glGetError(); //glDrawArrays(GL_TRIANGLES, 0, 3); glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, AE_GL_BUFFER_OFFSET(0)); error = glGetError(); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ARRAY_BUFFER, 0); /*glColor3f(1.0, 1.0, 1.0); glBegin(GL_POLYGON); glVertex3f(0.25, 0.25, 0.0); glVertex3f(0.75, 0.25, 0.0); glVertex3f(0.75, 0.75, 0.0); glVertex3f(0.25, 0.75, 0.0); glEnd();*/ //glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glViewport(0, 0, 300, 300); // Reset the coordinate system before modifying glMatrixMode(GL_PROJECTION); glLoadIdentity(); // Pseudo window coordinates gluOrtho2D(0.0, (GLfloat) 300, 0.0f, (GLfloat) 300); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); GLuint *pImage = (GLuint *)(malloc(sizeof(GLuint))); pImage[0] = 0xFFFF00FF; glRasterPos2i(50, 50); glDrawPixels(1, 1, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pImage); free(pImage); ::SwapBuffers(deviceContext); }
void print_info() { glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluOrtho2D(0, gWidth, gHeight, 0); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glDisable(GL_BLEND); glColor3f(0.0, 0.0, 0.0); glRasterPos2i(5, 15); std::chrono::milliseconds millis = std::chrono::duration_cast<std::chrono::milliseconds>(gFramePeriod); std::stringstream s; s << "Framerate: " << 1000.0/millis.count(); printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 30); s.str("");// = std::stringstream(); s.clear(); s << "Tracers: " << tracers.size(); printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 45); s.str(""); s.clear(); s << "Vortons: " << vortons.size(); printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 60); s.clear(); s.str(""); s << "Vortons per: " << vortons_per; printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 75); s.str(""); s.clear(); s << "Tracers per: " << tracers_per; printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 90); s.str(""); s.clear(); s << "Tracers per thread: " << leaf_coarseness; printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 105); s.str(""); s.clear(); s << "Timestep: " << gTimeStep; printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 120); s.str(""); s.clear(); s << "Vel spread: " << flow->dx; printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 135); s.str(""); s.clear(); s << "Vort spread: " << flow->dv; printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 150); s.str(""); s.clear(); s << "Tracer shape: " << (flow->sphere? "sphere" : "torus"); printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glRasterPos2i(5, 165); s.str(""); s.clear(); s << "Tracer surface: " << (flow->surface? "true" : "false"); printtoscreen(GLUT_BITMAP_HELVETICA_12, s.str()); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); }
// Write( const char *, float, float ): // Writes a string of text to the OpenGL viewport at the coordinates // specifed. bool GLTBitmapFont::Write( const char *string, int x, int y ) { glRasterPos2i( x, y ); return Write( string ); }
void drawString(int x, int y, const std::string& str, void* font=GLUT_BITMAP_8_BY_13) { glRasterPos2i(x, y); }
/* * Displays a menu box and all of its submenus (if they are active) */ static void fghDisplayMenuBox( SFG_Menu* menu ) { SFG_MenuEntry *menuEntry; int i; int border = FREEGLUT_MENU_BORDER; /* * Have the menu box drawn first. The +- values are * here just to make it more nice-looking... */ /* a non-black dark version of the below. */ glColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); glBegin( GL_QUAD_STRIP ); glVertex2i( menu->Width , 0 ); glVertex2i( menu->Width - border, border); glVertex2i( 0 , 0 ); glVertex2i( border, border); glVertex2i( 0 , menu->Height ); glVertex2i( border, menu->Height - border); glEnd( ); /* a non-black dark version of the below. */ glColor4f( 0.5f, 0.5f, 0.5f, 1.0f ); glBegin( GL_QUAD_STRIP ); glVertex2i( 0 , menu->Height ); glVertex2i( border, menu->Height - border); glVertex2i( menu->Width , menu->Height ); glVertex2i( menu->Width - border, menu->Height - border); glVertex2i( menu->Width , 0 ); glVertex2i( menu->Width - border, border); glEnd( ); glColor4fv( menu_pen_back ); glBegin( GL_QUADS ); glVertex2i( border, border); glVertex2i( menu->Width - border, border); glVertex2i( menu->Width - border, menu->Height - border); glVertex2i( border, menu->Height - border); glEnd( ); /* Check if any of the submenus is currently active... */ for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) { /* Has the menu been marked as active, maybe? */ if( menuEntry->IsActive ) { /* * That's truly right, and we need to have it highlighted. * There is an assumption that mouse cursor didn't move * since the last check of menu activity state: */ int menuID = menuEntry->Ordinal; /* So have the highlight drawn... */ glColor4fv( menu_pen_hback ); glBegin( GL_QUADS ); glVertex2i( border, (menuID + 0)*FREEGLUT_MENU_HEIGHT + border ); glVertex2i( menu->Width - border, (menuID + 0)*FREEGLUT_MENU_HEIGHT + border ); glVertex2i( menu->Width - border, (menuID + 1)*FREEGLUT_MENU_HEIGHT + border ); glVertex2i( border, (menuID + 1)*FREEGLUT_MENU_HEIGHT + border ); glEnd( ); } } /* Print the menu entries now... */ glColor4fv( menu_pen_fore ); for( menuEntry = (SFG_MenuEntry *)menu->Entries.First, i = 0; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next, ++i ) { /* If the menu entry is active, set the color to white */ if( menuEntry->IsActive ) glColor4fv( menu_pen_hfore ); /* Move the raster into position... */ /* Try to center the text - JCJ 31 July 2003*/ glRasterPos2i( 2 * border, ( i + 1 )*FREEGLUT_MENU_HEIGHT - ( int )( FREEGLUT_MENU_HEIGHT*0.3 - border ) ); /* Have the label drawn, character after character: */ glutBitmapString( FREEGLUT_MENU_FONT, (unsigned char *)menuEntry->Text); /* If it's a submenu, draw a right arrow */ if( menuEntry->SubMenu ) { int width = glutBitmapWidth( FREEGLUT_MENU_FONT, '_' ); int x_base = menu->Width - 2 - width; int y_base = i*FREEGLUT_MENU_HEIGHT + border; glBegin( GL_TRIANGLES ); glVertex2i( x_base, y_base + 2*border); glVertex2i( menu->Width - 2, y_base + ( FREEGLUT_MENU_HEIGHT + border) / 2 ); glVertex2i( x_base, y_base + FREEGLUT_MENU_HEIGHT - border ); glEnd( ); } /* If the menu entry is active, reset the color */ if( menuEntry->IsActive ) glColor4fv( menu_pen_fore ); } }
void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, grid_texture); glColor3ub(255,255,255); glBegin(GL_QUADS); glTexCoord2f(1, 0); glVertex2f(grid.nx(), 0); glTexCoord2f(0, 0); glVertex2f(0, 0); glTexCoord2f(0, 1); glVertex2f(0, grid.ny()); glTexCoord2f(1, 1); glVertex2f(grid.nx(), grid.ny()); glEnd(); glDisable(GL_TEXTURE_2D); /*if (valid(init)) { glPushMatrix(); glColor3ub(63,255,63); glTranslated(init.x(), init.y(), 0); gluDisk(quadric, 0, goalr, 32, 1); glRotated(initTheta*180/M_PI, 0, 0, 1); glBegin(GL_TRIANGLES); glVertex2f(6, 0); glVertex2f(0, 2); glVertex2f(0, -2); glEnd(); glPopMatrix(); }*/ /*if (valid(goal)) { glPushMatrix(); glColor3ub(255,63,63); glTranslated(goal.x(), goal.y(), 0); gluDisk(quadric, 0, goalr, 32, 1); glPopMatrix(); }*/ drawInputSegments(); for(int i = 0; i < bipedTrajectory.size(); i++){ RobotSegment curstate = stateTraj->at(i); drawInitialState(curstate.robot_pos[0], curstate.robot_pos[1], curstate.theta); draw(bipedTrajectory[i], true); } //draw(searchResult, true); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluOrtho2D(0, width, 0, height); std::ostringstream ostr; ostr << "Goal pos: (" << goal.x() << ", " << goal.y() << ")\n" << "Init pos: (" << init.x() << ", " << init.y() << ")\n" << "Init theta: " << initTheta*180/M_PI << "\n" << "XY inflation: " << inflate_h << "\n" << "Z inflation: " << inflate_z << "\n" << "Max depth: " << maxDepth << "\n" << "View depth: " << viewDepth << "\n" << "Auto-plan: " << (auto_plan ? "on" : "off") << "\n" << "\n" << "Plan cost: " << (searchResult ? searchResult->costToCome : 0) << "\n" << "Plan time: " << (searchResult ? planTime : 0) << "\n"; if (show_help) { ostr << "\n\n" << " Left-click init pos\n" << "Shift+click init theta\n" << "Right-click goal pos\n\n" << " 1/2 max depth\n" << " 3/4 view depth\n" << " -/+ XY inflation\n" << " A auto-plan\n" << " Enter re-plan\n" << " ESC quit\n" << " ? hide help"; } else { ostr << "\nPress ? to toggle help."; } std::string str = ostr.str(); void* font = GLUT_BITMAP_8_BY_13; const int tx = 8; const int ty = 13; const int th = ty+2; int maxwidth = 0; int linewidth = 0; int rh = th; for (size_t i=0; i<str.length(); ++i) { char c = str[i]; if (c == '\n') { maxwidth = std::max(maxwidth, linewidth); linewidth = 0; rh += th; } else { linewidth += tx; } } maxwidth = std::max(maxwidth, linewidth); int rw = maxwidth + 20; rh += 10; glColor4ub(191,191,255,225); glEnable(GL_BLEND); glBegin(GL_QUADS); glVertex2f( 0, height); glVertex2f(rw, height); glVertex2f(rw, height-rh); glVertex2f( 0, height-rh); glEnd(); glDisable(GL_BLEND); int rx = 10; int ry = height-th; glColor3ub(0,0,0); glRasterPos2i(rx, ry); for (size_t i=0; i<str.length(); ++i) { char c = str[i]; if (c == '\n') { ry -= th; glRasterPos2i(rx, ry); } else { glutBitmapCharacter(font, str[i]); } } glPopMatrix(); glutSwapBuffers(); }
void display(void) { glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); int flag=0,i; glColor3f(0.5,0.5,0.5); glBegin(GL_POLYGON); glVertex2i(200,100); glVertex2i(200,325); glVertex2i(425,325); glVertex2i(425,100); glEnd(); glBegin(GL_LINES); glVertex2i(427,327); glVertex2i(427,102); glVertex2i(426,326); glVertex2i(426,101); glEnd(); glColor3f(0,0,0.0); glBegin(GL_POINTS); glVertex2i(05,5); // glVertex2i(427,102); // glVertex2i(426,326); // glVertex2i(426,101); glEnd(); glColor3f(1.0,0.0,0.0); glBegin(GL_LINE_LOOP); // boundary lines glVertex2i(200,100); glVertex2i(200,325); glVertex2i(425,325); glVertex2i(425,100); glEnd(); glBegin(GL_LINES); // for 3D effect glVertex2i(427,327); glVertex2i(427,102); glVertex2i(426,326); glVertex2i(426,101); glVertex2i(428,328); glVertex2i(428,103); glVertex2i(201,326); glVertex2i(426,326); glVertex2i(202,327); glVertex2i(427,327); glVertex2i(203,328); glVertex2i(428,328); glEnd(); glBegin(GL_LINES); // horizontal and vertical lines glVertex2i(275,100); glVertex2i(275,325); glVertex2i(200,175); glVertex2i(425,175); glVertex2i(350,100); glVertex2i(350,325); glVertex2i(200,250); glVertex2i(425,250); glEnd(); glColor3f(0.0,1.0,1.0); glRasterPos2i(240,50); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'M'); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'O'); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'V'); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'E'); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,'S'); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,':'); glRasterPos2i(340,50); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,s1+48); glRasterPos2i(328,50); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,s2+48); glRasterPos2i(316,50); glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,s3+48); for(int i=1;i<=9;i++) { if(a[i]==0) continue; printf("\n %d %d ",xx[i],yy[i]); glColor3f(0.0,1.0,1.0); glBegin(GL_POLYGON); glVertex2i(xx[i],yy[i]); glVertex2i(xx[i],yy[i]+55); glVertex2i(xx[i]+55,yy[i]+55); glVertex2i(xx[i]+55,yy[i]); glEnd(); glColor3f(0.0,0.0,0.2); glBegin(GL_LINE_LOOP); // boundary lines glVertex2i(xx[i],yy[i]); glVertex2i(xx[i],yy[i]+55); glVertex2i(xx[i]+55,yy[i]+55); glVertex2i(xx[i]+55,yy[i]); glEnd(); glColor3f(1.0,0.0,0.0); glRasterPos2i(xx[i]+23,yy[i]+23); int c=a[i]+48; glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,c); } for(i=1;i<=8;i++) { if(a[i] != i) flag=1; } if(flag==0) { glRasterPos2i(300,400); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'W'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'i'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'n'); glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,'!'); } glFlush(); }
static void drawfire(void) { static char frbuf[80] = ""; int j; dojoy(); if (NiceFog) glHint(GL_FOG_HINT, GL_NICEST); else glHint(GL_FOG_HINT, GL_DONT_CARE); glEnable(GL_DEPTH_TEST); if (fog) glEnable(GL_FOG); else glDisable(GL_FOG); glDepthMask(GL_TRUE); glClearColor(1.0, 1.0, 1.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); calcposobs(); gluLookAt(obs[0], obs[1], obs[2], obs[0] + dir[0], obs[1] + dir[1], obs[2] + dir[2], 0.0, 1.0, 0.0); glColor4f(1.0, 1.0, 1.0, 1.0); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, groundid); #if 1 glBegin(GL_QUADS); glTexCoord2fv(qt[0]); glVertex3fv(q[0]); glTexCoord2fv(qt[1]); glVertex3fv(q[1]); glTexCoord2fv(qt[2]); glVertex3fv(q[2]); glTexCoord2fv(qt[3]); glVertex3fv(q[3]); glEnd(); #else /* Subdivide the ground into a bunch of quads. This improves fog * if GL_FOG_HINT != GL_NICEST */ { float x, y; float dx = 1.0, dy = 1.0; glBegin(GL_QUADS); for (y = -DIMP; y < DIMP; y += 1.0) { for (x = -DIMP; x < DIMP; x += 1.0) { glTexCoord2f(0, 0); glVertex3f(x, 0, y); glTexCoord2f(1, 0); glVertex3f(x+dx, 0, y); glTexCoord2f(1, 1); glVertex3f(x+dx, 0, y+dy); glTexCoord2f(0, 1); glVertex3f(x, 0, y+dy); } } glEnd(); } #endif glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GEQUAL, 0.9); glBindTexture(GL_TEXTURE_2D, treeid); for (j = 0; j < NUMTREE; j++) drawtree(treepos[j][0], treepos[j][1], treepos[j][2]); glDisable(GL_TEXTURE_2D); glDepthMask(GL_FALSE); glDisable(GL_ALPHA_TEST); if (shadows) { glBegin(GL_TRIANGLES); for (j = 0; j < np; j++) { glColor4f(black[0], black[1], black[2], p[j].c[0][3]); glVertex3f(p[j].p[0][0], 0.1, p[j].p[0][2]); glColor4f(black[0], black[1], black[2], p[j].c[1][3]); glVertex3f(p[j].p[1][0], 0.1, p[j].p[1][2]); glColor4f(black[0], black[1], black[2], p[j].c[2][3]); glVertex3f(p[j].p[2][0], 0.1, p[j].p[2][2]); } glEnd(); } glBegin(GL_TRIANGLES); for (j = 0; j < np; j++) { glColor4fv(p[j].c[0]); glVertex3fv(p[j].p[0]); glColor4fv(p[j].c[1]); glVertex3fv(p[j].p[1]); glColor4fv(p[j].c[2]); glVertex3fv(p[j].p[2]); setpart(&p[j]); } glEnd(); glDisable(GL_TEXTURE_2D); glDisable(GL_ALPHA_TEST); glDisable(GL_DEPTH_TEST); glDisable(GL_FOG); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glColor3f(1.0, 0.0, 0.0); glRasterPos2i(10, 10); printstring(GLUT_BITMAP_HELVETICA_18, frbuf); glRasterPos2i(370, 470); printstring(GLUT_BITMAP_HELVETICA_10, "Fire V1.5 Written by David Bucciarelli ([email protected])"); if (help) printhelp(); reshape(WIDTH, HEIGHT); glPopMatrix(); glutSwapBuffers(); Frames++; { GLint t = glutGet(GLUT_ELAPSED_TIME); if (t - T0 >= 2000) { GLfloat seconds = (t - T0) / 1000.0; GLfloat fps = Frames / seconds; sprintf(frbuf, "Frame rate: %f", fps); T0 = t; Frames = 0; } } }