Ejemplo n.º 1
0
void HelpDisplay(GLint ww, GLint wh)
{
    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
    glColor3f(1.0f, 1.0f, 1.0f);


    /*  switch to projection mode */
    glMatrixMode(GL_PROJECTION);
    /*  save previous matrix which contains the  */
    /* settings for the perspective projection */
    glPushMatrix();
    /*  reset matrix */
    glLoadIdentity();
    /*  set a 2D orthographic projection */
    gluOrtho2D(0, ww, 0, wh);
    /*  invert the y axis, down is positive */
    glScalef(1, -1, 1);
    /*  mover the origin from the bottom left corner */
    /*  to the upper left corner */
    glTranslatef(0, -wh, 0);
    glMatrixMode(GL_MODELVIEW);


    glPushMatrix();
    glLoadIdentity();
    linestart = 10;

    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font, "Help Menu");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font, "---------");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "H/h = Toggle Help Menu");
    if (!full_screen)
	HelpRenderBitmapString(30, linestart +=
			       linespace, Help_Font,
			       "TAB = Activate Full Screen");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "Esc = Exits Program");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "R/r = Reset Position");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "C/c = Toggle Axis");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "W/w = Toggle Wireframe");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "D/d = Toggle Double Sided Polygons");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "S/s = Toggle Smooth Shading");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "M/m = Toggle Materials");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "T/t = Toggle Textures");
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "B/b = Toggle Auto Rotate");
    /* HelpRenderBitmapString(30,linestart+=linespace,(void *)Help_Font, "L/l = Toggle Line Smoothing");    */
#ifdef AVL
    HelpRenderBitmapString(30, linestart +=
			   linespace, Help_Font,
			   "F/f = Flip Textures");
#endif

    if (stereo) {
	HelpRenderBitmapString(30, linestart +=
			       linespace, Help_Font,
			       "Stereo Variables");
	HelpRenderBitmapString(30, linestart +=
			       linespace, Help_Font,
			       "----------------");
	HelpRenderBitmapString(30, linestart +=
			       linespace, Help_Font,
			       "</, = Decrease Eye Separation");
	HelpRenderBitmapString(30, linestart +=
			       linespace, Help_Font,
			       ">/. = Increase Eye Separation");
	HelpRenderBitmapString(30, linestart +=
			       linespace, Help_Font,
			       "+/- = Increase/Decrease Focus Distance");
    }

    glPopMatrix();

    /*  set the current matrix to GL_PROJECTION */
    glMatrixMode(GL_PROJECTION);
    /*  restore previous settings */
    glPopMatrix();
    /*  get back to GL_MODELVIEW matrix */
    glMatrixMode(GL_MODELVIEW);

    if (lighting)
	glEnable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
}
void TransIcelandicExpress::redraw( void ) {	

	static tex_init = 0;	

	
	if (!tex_init) {		

		ilutRenderer( ILUT_OPENGL );

		ilGenImages( 1, &ImageName );

		ilBindImage( ImageName );
		glEnable( GL_TEXTURE_2D );
		glEnable( GL_BLEND );
		glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
	
		if (!ilLoadImage( "ludum48.png" )) {
			printf("Loading image failed\n");
		}

		
		gl_tex_id = ilutGLBindTexImage();
		ilutGLTexImage( 0 );

		tex_init = 1;
	} 

	glBindTexture (GL_TEXTURE_2D, gl_tex_id );

	glClearColor( 0.3f, 0.4f, 0.6f, 1.0f );
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	//glEnable( GL_CULL_FACE );
	glEnable( GL_DEPTH_TEST );

	// 3d part
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
	gluPerspective( 60.0, 800.0/600.0, 0.05, 100.0 );



	gluLookAt(	player->pos[0]+cameraPos[0], 
				player->pos[1]+cameraPos[1]+c_PlayerHeight, 
				player->pos[2]+cameraPos[2],

				player->pos[0], 
				player->pos[1]+ c_PlayerHeight, 
				player->pos[2],

				0.0, 1.0, 0.0 );
				

	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();

	// apply some of the camera xform to the light just to make
	// it more shiny
	glPushMatrix();
	float viewHead = atan2( cameraPos[2], cameraPos[0] );	
	glRotated( viewHead * SG_RADIANS_TO_DEGREES, 0.0f, 1.0f, 0.0f );
	setupLights();
	glPopMatrix();

	draw3d();

	// 2d part
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();	
	gluOrtho2D( 0, 800, 0, 600 ) ;

	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();

	glDisable( GL_LIGHTING );
	draw2d();

	SDL_GL_SwapBuffers();

}
Ejemplo n.º 3
0
// The constructor creates a texture of the track data, such that the track
// layout can be displayed efficiently. Additional data gets initialized.
cGrTrackMap::cGrTrackMap()
{
	// Hardcoded initial view mode, available per instance.
	viewmode = TRACK_MAP_NORMAL_WITH_OPPONENTS;

	// For all views we need the same track texture, so create it just once.
	if (isinitalized) {
		return;
	} else {
		// Initialize colors for the various car "dots".
		initColors();

		tTrack *track = grTrack;
		tTrackSeg* first = track->seg;
		tTrackSeg* seg = first;

		// Search the maximum/minimum x/y values of the track (axis aligned bounding box),
		// to compute later the texture parameters and to be able to place the cars (dots)
		// correct. The impementation is inefficient, but it's just executed one time per
		// race, so it doesn't matter.
		track_min_x = FLT_MAX;
		track_max_x = -FLT_MAX;
		track_min_y = FLT_MAX;
		track_max_y = -FLT_MAX;

		do {
			// We analyse the straight and turns different, because (read on)
			if (seg->type == TR_STR) {
				// Straights are trivial, because the corners are sufficient to create a
				// bounding box.
				// TODO: If CCW/CW is known, you just need to check one side (the outside).
				// TODO: More effiecient checking.
				checkAndSetMinimum(track_min_x, seg->vertex[TR_SL].x);
				checkAndSetMinimum(track_min_x, seg->vertex[TR_SR].x);
				checkAndSetMinimum(track_min_y, seg->vertex[TR_SL].y);
				checkAndSetMinimum(track_min_y, seg->vertex[TR_SR].y);

				checkAndSetMaximum(track_max_x, seg->vertex[TR_SL].x);
				checkAndSetMaximum(track_max_x, seg->vertex[TR_SR].x);
				checkAndSetMaximum(track_max_y, seg->vertex[TR_SL].y);
				checkAndSetMaximum(track_max_y, seg->vertex[TR_SR].y);
			} else {
				// Turns are not that easy, think of a definition of a circle or an arc. If you
				// just consider the corners the bounding box might be any order too small
				// or too big.
				// To avoid that we create intermediate steps, such that we get a defined
				// accuracy (e.g. 5 meters).
				float curseglen = 0.0;
				float dphi = RESOLUTION / seg->radius;
				double xc = seg->center.x;
				double yc = seg->center.y;
				dphi = (seg->type == TR_LFT) ? dphi : -dphi;
				float phi = 0.0;

				while (curseglen < seg->length) {
					float cs = cos(phi), ss = sin(phi);
					// TODO: If CCW/CW is known, you just need to check one side (the outside).
					float lx, ly, rx, ry;
					lx = seg->vertex[TR_SL].x * cs - seg->vertex[TR_SL].y * ss - xc * cs + yc * ss + xc;
					ly = seg->vertex[TR_SL].x * ss + seg->vertex[TR_SL].y * cs - xc * ss - yc * cs + yc;

					rx = seg->vertex[TR_SR].x * cs - seg->vertex[TR_SR].y * ss - xc * cs + yc * ss + xc;
					ry = seg->vertex[TR_SR].x * ss + seg->vertex[TR_SR].y * cs - xc * ss - yc * cs + yc;

					// TODO: More effiecient checking.
					checkAndSetMinimum(track_min_x, lx);
					checkAndSetMinimum(track_min_x, rx);
					checkAndSetMinimum(track_min_y, ly);
					checkAndSetMinimum(track_min_y, ry);

					checkAndSetMaximum(track_max_x, lx);
					checkAndSetMaximum(track_max_x, rx);
					checkAndSetMaximum(track_max_y, ly);
					checkAndSetMaximum(track_max_y, ry);

					curseglen += RESOLUTION;
					phi += dphi;
				}
			}
			seg = seg->next;
		} while (seg != first);

		// Compute the maximum possible texture size possible to create the track texture.
		// TODO: use pbuffer if available or subdivide and render/readback in multiple passes.
		int texturesize = 1;
		int maxtexturesize = MIN(grWinw, grWinh);
		while (texturesize <= maxtexturesize) {
			texturesize <<= 1;
		}
		texturesize >>= 1;

		// Get maximum OpenGL texture size and reduce texturesize if necessary.
		int maxOpenGLtexturesize;
		glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxOpenGLtexturesize);
		if (texturesize > maxOpenGLtexturesize) {
			texturesize = maxOpenGLtexturesize;
		}

		// Compute an estimate of the overall width and height of the track in [m].
		track_width = track_max_x - track_min_x;
		track_height = track_max_y - track_min_y;

		// Compute the final line width to draw the track.
		float linewidth = MIN(MAXLINEWIDTH, MINLINEWIDTH*4000.0/MAX(track_width, track_height));
		linewidth = linewidth*(texturesize/512.0);

		// Compute a first estimate of the pixel to distance ratio.
		ratio = texturesize/MAX(track_width, track_height);

		// Compute final minimum/maximum values.
		track_max_x = track_max_x + RESOLUTION + linewidth/ratio;
		track_max_y = track_max_y + RESOLUTION + linewidth/ratio;
		track_min_x = track_min_x - RESOLUTION - linewidth/ratio;
		track_min_y = track_min_y - RESOLUTION - linewidth/ratio;

		// Compute final ratio, width and height.
		track_width = track_max_x - track_min_x;
		track_height = track_max_y - track_min_y;
		ratio = texturesize/MAX(track_width, track_height);

		// Compute the ratios
		if (track_width >= track_height) {
			track_x_ratio = 1.0;
			track_y_ratio = track_height/track_width;
		} else {
			track_y_ratio = 1.0;
			track_x_ratio = track_width/track_height;
		}

		isinitalized = true;

		// Now we are ready to render the track into the framebuffer (backbuffer).
		// Clear the framebuffer (backbuffer), make it "transparent" (alpha = 0.0).
		glFinish();
		glClearColor(0.0, 0.0, 0.0, 0.0);
		glClear(GL_COLOR_BUFFER_BIT);

		// Set transformations and projection such that one pixel is one unit.
		glViewport (grWinx, grWiny, grWinw, grWinh);
		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glLoadIdentity();

		glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0, grWinw, 0.0, grWinh);
		glMatrixMode(GL_MODELVIEW);

		// Now draw the track as quad strip. The reason for that is that drawing with
		// glEnable(GL_LINE_SMOOTH) and glHint(GL_LINE_SMOOTH_HINT, GL_NICEST) caused problems
		// with the alpha channel.
		float halflinewidth = linewidth/2.0;
		bool firstvert = true;
		float xf1, yf1 , xf2, yf2;
		xf1 = yf1 = xf2 = yf2 = 0.0;
		glBegin(GL_QUAD_STRIP);
		seg = first;
		do {
			if (seg->type == TR_STR) {
				// Draw a straight.
				// Compute global coordinate on track middle.
				float xm = (seg->vertex[TR_SL].x + seg->vertex[TR_SR].x) / 2.0;
				float ym = (seg->vertex[TR_SL].y + seg->vertex[TR_SR].y) / 2.0;
				xm = (xm - track_min_x)*ratio;
				ym = (ym - track_min_y)*ratio;

				// Compute normal to the track middle.
				float xn = seg->vertex[TR_SL].x - seg->vertex[TR_SR].x;
				float yn = seg->vertex[TR_SL].y - seg->vertex[TR_SR].y;
				float length = sqrt(xn*xn+yn*yn);
				xn /= length;
				yn /= length;

				// Compute the new points.
				float x1 = (xm - xn*halflinewidth);
				float y1 = (ym - yn*halflinewidth);
				float x2 = (xm + xn*halflinewidth);
				float y2 = (ym + yn*halflinewidth);

				if (firstvert) {
					firstvert = false;
					xf1 = x1;
					yf1 = y1;
					xf2 = x2;
					yf2 = y2;
				}
				glVertex2f(x1, y1);
				glVertex2f(x2, y2);
			} else {
				// To draw the turns correct we subdivide them again, like above.
				float curseglen = 0.0;
				float dphi = RESOLUTION / seg->radius;
				double xc = seg->center.x;
				double yc = seg->center.y;
				dphi = (seg->type == TR_LFT) ? dphi : -dphi;
				float mx = (seg->vertex[TR_SL].x + seg->vertex[TR_SR].x) / 2.0;
				float my = (seg->vertex[TR_SL].y + seg->vertex[TR_SR].y) / 2.0;
			    float phi = 0.0;

				while (curseglen < seg->length) {
					float cs = cos(phi), ss = sin(phi);
					float x = mx * cs - my * ss - xc * cs + yc * ss + xc;
					float y = mx * ss + my * cs - xc * ss - yc * cs + yc;

					float xn = x - xc;
					float yn = y - yc;
					float length = sqrt(xn*xn+yn*yn);
					xn /= length;
					yn /= length;

					x = (x - track_min_x)*ratio;
					y = (y - track_min_y)*ratio;

					float x1 = (x + xn*halflinewidth);
					float y1 = (y + yn*halflinewidth);
					float x2 = (x - xn*halflinewidth);
					float y2 = (y - yn*halflinewidth);

					if (seg->type == TR_LFT) {
						glVertex2f(x1, y1);
						glVertex2f(x2, y2);
						if (firstvert) {
							firstvert = false;
							xf1 = x1;
							yf1 = y1;
							xf2 = x2;
							yf2 = y2;
						}
					} else {
						glVertex2f(x2, y2);
						glVertex2f(x1, y1);
						if (firstvert) {
							firstvert = false;
							xf1 = x2;
							yf1 = y2;
							xf2 = x1;
							yf2 = y1;
						}
					}

					curseglen += RESOLUTION;
					phi += dphi;
				}
			}
			seg = seg->next;
		} while (seg != first);

		if (!firstvert) {
			glVertex2f(xf1, yf1);
			glVertex2f(xf2, yf2);
		}
		glEnd();

		// Read track picture into memory to be able to generate mipmaps. I read back an RGBA
		// image because I don't know yet what people want to add to the map, so RGBA is most
		// flexible to add things like start line, elevation coloring etc.
		// Do not use GL_ALPHA or GL_LUMINANCE to save memory, somehow this leads to a
		// performance penalty (at least on NVidia cards).
		GLuint *trackImage = (GLuint*) malloc(texturesize*texturesize*sizeof(GLuint));
		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
		glPixelStorei(GL_PACK_ALIGNMENT, 1);
		glReadBuffer(GL_BACK);
		glReadPixels(0, 0, texturesize, texturesize, GL_RGBA, GL_BYTE, trackImage);

		// Check if the color buffer has alpha, if not fix the texture. Black gets
		// replaced by transparent black, so don't draw black in the texture, you
		// won't see anything.
		if (glutGet(GLUT_WINDOW_ALPHA_SIZE) == 0) {
			// There is no alpha, so we fix it manually. Because we added a little border
			// around the track map the first pixel should always contain the
			// clearcolor.
			GLuint clearcolor = trackImage[0];
			int i;
			for (i = 0; i < texturesize*texturesize; i++) {
				if (trackImage[i] == clearcolor) {
					// Assumption: transparent black is 0, portable?
					trackImage[i] = 0;
				}
			}
		}

		// Finally copy the created image of the track from the framebuffer into the texture.
		glGenTextures (1, &mapTexture);
		glBindTexture(GL_TEXTURE_2D, mapTexture);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);


		// If GL_ARB_texture_compression is available at runtime, (try to) compress the
		// texture. This is done with the specification of the internal format to
		// GL_COMPRESSED_RGBA_ARB.
		if (isCompressARBAvailable()) {
			// This texture contains mostly the clear color value and should therefore
			// compress well even with high quality.
			glHint(GL_TEXTURE_COMPRESSION_HINT_ARB, GL_NICEST);
			gluBuild2DMipmaps(GL_TEXTURE_2D, GL_COMPRESSED_RGBA_ARB, texturesize, texturesize, GL_RGBA, GL_BYTE, trackImage);
			// The following commented code is just for testing purposes.
			/*int compressed;
			glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_ARB, &compressed);
			if (compressed == GL_TRUE) {
				int csize;
				printf("compression succesful!\n");
				glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, &csize);
				printf("compression ratio: %d to %d\n", csize, texturesize*texturesize*sizeof(GLuint));
			}*/
		} else {
			// GL_ARB_texture_compression not available at runtime, fallback.
			gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, texturesize, texturesize, GL_RGBA, GL_BYTE, trackImage);
		}

		// Free the memory of the initial texture.
		free(trackImage);

		// Init the position and size of the map in the window.
		map_x = -10;
		map_y = -40;
		map_size = 170;

		// Restore some state.
		glPopMatrix();

		// Compile the car "dot" display list.
		cardot = glGenLists(1);
		if (cardot != 0) {
			glNewList(cardot, GL_COMPILE);
			glBegin(GL_TRIANGLE_FAN);
			// The center.
			glVertex2f(0.0, 0.0);
			// The border.
			int i;
			const int borderpoints = 8;
			halflinewidth = halflinewidth*float(map_size)/float(texturesize);
			for (i = 0; i < borderpoints + 1; i++) {
				float phi = 2.0*PI*float(i)/float(borderpoints);
				glVertex2f(halflinewidth*cos(phi), halflinewidth*sin(phi));
			}
			glEnd();
			glEndList();
		}

		// Clear the screen, that in case of a delay the track is not visible.
		glClear(GL_COLOR_BUFFER_BIT);
	}
}
Ejemplo n.º 4
0
int Splat_Prepare(SDL_Window *userWindow, int userViewportWidth, int userViewportHeight) {
  int width, height;
  window = userWindow;
  viewportWidth = userViewportWidth;
  viewportHeight = userViewportHeight;
  SDL_GetWindowSize(userWindow, &width, &height);

  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 4);
  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 4);
  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 4);
  SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 4);
  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

  window_glcontext = SDL_GL_CreateContext(window);
  if (!window_glcontext) {
    Splat_SetError("OpenGL context creation failed.  Check glGetError() and/or SDL_GetError() for more information.");
    Splat_Finish();
    return -1;
  }

  // Our shading model--Flat
  glShadeModel(GL_FLAT);

  // Default the clear color to black.
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

  // Setup our viewport.
  glViewport(0, 0, viewportWidth, viewportHeight);

  // Change to the projection matrix and set up our ortho view
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0, width, 0, height);

  // Set up modelview for 2D integer coordinates
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(0.375f, height + 0.375f, 0.0f);
  glScalef(1.0f, -1.0f, 0.001f); // Make the positive Z-axis point "out" from the view (e.g images at depth 4 will be higher than those at depth 0), and swap the Y axis

  /* Deactivate the system cursor */
  SDL_ShowCursor(SDL_DISABLE);

  glDisable(GL_DITHER);

  /* Create the frame buffer for rendering to texture*/
  glGenFramebuffers(1, &framebuffer);

  glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

  /* Set up the texture to which we're going to render */
  glGenTextures(1, &frameTexture);
  glBindTexture(GL_TEXTURE_2D, frameTexture);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, viewportWidth, viewportHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

  /* Configure the framebuffer texture */
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, frameTexture, 0);
  GLenum DrawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
  glDrawBuffers(1, DrawBuffers);

  GLenum err = glGetError();
  if (err != GL_NO_ERROR) {
    Splat_SetError("OpenGL error occurred during initialization");
    Splat_Finish();
    return -1;
  }

  return 0;
}
Ejemplo n.º 5
0
    virtual void redraw( void ) {
        static bool first=true;
        static RenderNode rn;

        int i;
        double tbalance;
        GeoLoadManager::ResultT region;
        if (_internalRoot == NullFC)
        {
            initialize();
            showAll();
        }
        _cart->getSFMatrix()->setValue(_navigator.getMatrix());    
        updateHighlight();
        _win->activate();
        _win->frameInit();
        if(first)
        {
            loadManager=new GeoLoadManager(useFaceDistribution);
            first=false;
            rn.determinePerformance(_win);
        }
        if(_win->getPort().size() < (serverCount+1))
        {
            ViewportPtr vp,ovp=_win->getPort(0);
            addRefCP(ovp);
            addRefCP(ovp);
            TileCameraDecoratorPtr deco;
            for(int i=_win->getPort().size()-1;i<serverCount;i++)
            {
                cout << "Add new" << endl;
                loadManager->addRenderNode(rn,i);
                if(simulateRendering)
                {
                    beginEditCP(_win);
                    deco=TileCameraDecorator::create();
                    beginEditCP(deco);
                    deco->setFullWidth ( _win->getWidth() );
                    deco->setFullHeight( _win->getHeight() );
                    deco->setDecoratee( ovp->getCamera() );
                    vp=Viewport::create();
                    beginEditCP(vp);
                    vp->setRoot      ( ovp->getRoot()       );

                    /*
                    SkyBackgroundPtr sky = SkyBackground::create();
                    beginEditCP(sky);
                    sky->setSphereRes(16);
                    
                    sky->getMFSkyColor()->addValue(Color3f(0, 0, .2));
                    sky->getMFSkyAngle()->addValue(Pi / 2);
                    sky->getMFSkyColor()->addValue(Color3f(.6, .6, 1)); 
                    
                    sky->getMFGroundColor()->addValue(Color3f(0, .3, 1));
                    sky->getMFGroundAngle()->addValue(Pi / 2);
                    sky->getMFGroundColor()->addValue(Color3f(1, .3, 0));

                    endEditCP(sky);
                    vp->setBackground( sky );
                    */

                    vp->setBackground( ovp->getBackground() );
                    vp->getMFForegrounds()->setValues( ovp->getForegrounds() );
                    vp->setCamera(deco);
                    _win->addPort(vp);
                    endEditCP(_win);
                    endEditCP(vp);
                    endEditCP(deco);
                }
            }
        }
        tbalance = -getSystemTime();
        loadManager->update(_win->getPort()[0]->getRoot());
        loadManager->balance(_win->getPort()[0],false,region);
        tbalance += getSystemTime();
        if(simulateRendering)
        {
            ViewportPtr vp;
            TileCameraDecoratorPtr deco;
            for(i=0;i<region.size();i+=4)
            {
#if 1
                cout << "Region: " << i << " ";
                cout << region[i+0] << " ";
                cout << region[i+1] << " ";
                cout << region[i+2] << " ";
                cout << region[i+3] << endl;
                if(region[i+0] >= region[i+2]) {
                    cout << "!!!" << endl;
                    region[i+2]++;
                }
                if(region[i+1] >= region[i+3]) {
                    cout << "!!!" << endl;
                    region[i+3]++;
                }
#endif
                vp=_win->getPort()[i/4+1];
                deco=TileCameraDecoratorPtr::dcast(vp->getCamera());
                beginEditCP(deco);
                beginEditCP(vp);
                vp->setSize(region[i+0],
                            region[i+1],
                            region[i+2],
                            region[i+3]);
                deco->setSize(region[i+0]/(float)_win->getWidth(),
                              region[i+1]/(float)_win->getHeight(),
                              region[i+2]/(float)_win->getWidth(),
                              region[i+3]/(float)_win->getHeight());
                endEditCP(deco);
                endEditCP(vp);
            }
        }
        Time t,tmin,tmax;
        for(i=0;i<_win->getPort().size();++i)
        {
            t=-getSystemTime();
            _action->setWindow( _win.getCPtr() );
            _win->getPort(i)->render( _action );
            glFlush();
            t+=getSystemTime();
            if(i==0)
                continue;
            if(i==1)
            {
                tmin=tmax=t;
            }
            else
            {
                if(t<tmin) tmin=t;
                if(t>tmax) tmax=t;
            }
        }
        if(!cache)
            printf("speed %5d %10.6f %10.6f %10.6f\n",_win->getPort().size()-1,
                   tmin,
                   tmax,
                   tbalance);
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glDisable(GL_SCISSOR_TEST);
        glViewport(0,0,
                   _win->getWidth(),
                   _win->getHeight());
        if(viewVolume)
            loadManager->drawVolumes(_win);
        glPushMatrix();
        glLoadIdentity();
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        gluOrtho2D(0,_win->getWidth(),
                   0,_win->getHeight());
        glDisable(GL_DEPTH_TEST);
        glEnable(GL_COLOR_MATERIAL);
        for(i=0;i<region.size();i+=4)
        {
#if 0
            cout << "Region: ";
            cout << region[i+0] << " ";
            cout << region[i+1] << " ";
            cout << region[i+2] << " ";
            cout << region[i+3] << endl;
#endif
            glBegin(GL_LINE_LOOP);
            glColor3f(1, 1, 0);
            glVertex3f(region[i+0],region[i+1],0);
            glVertex3f(region[i+2],region[i+1],0);
            glVertex3f(region[i+2],region[i+3],0);
            glVertex3f(region[i+0],region[i+3],0);
            glEnd();
        }
        glDisable(GL_COLOR_MATERIAL);
        glEnable(GL_DEPTH_TEST);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
        glPopAttrib();

        if(doSave)
        {
            Int32 w,h;
            w=_win->getPort(0)->getPixelWidth();
            h=_win->getPort(0)->getPixelHeight();
            Image image(Image::OSG_RGB_PF,
                        w,h,1,
                        1,1,0.0,
                        NULL,true);
            ImageFileType *imgTransType=ImageFileHandler::the().getFileType("JPEG");
            char filename[256];
            if(imgTransType==NULL)
            {
                cerr << "Unknown image trans type" << endl;
                return;
            }
            sprintf(filename,"%s_%d.jpg",dumpImage,dumpImageNr++);
            // read buffer data into image
            glPixelStorei(GL_PACK_ALIGNMENT,1);
            glReadPixels(0,0,w,h,
                         GL_RGB,GL_UNSIGNED_BYTE,
                         image.getData());
            imgTransType->write(image,filename);
        }
        _win->swap();
        _win->frameExit();
    }
Ejemplo n.º 6
0
void display( void ) {

   int x[7], y[7];

   /*
    * Clear window  - glClear clears all buffers whose bits are set in mask
    * formed by logical OR of values defined in gl.h.  GL_COLOR_BUFFER_BIT
    * refers to color buffer.
    */
   glClear( GL_COLOR_BUFFER_BIT );

   /*
    * Set the viewWindow
    */
   glMatrixMode( GL_PROJECTION );
   glLoadIdentity( );
   gluOrtho2D( 0, 300, 0, 300 );

   /*
    * Set the viewport to match the viewWindow
    */
   glViewport( 0, 0, 299, 299 );

   /* 
    * Use Student's drawPolygon 
    */
   x[0] = 10; y[0] = 10;
   x[1] = 20; y[1] = 10;
   x[2] = 20; y[2] = 20;
   x[3] = 10; y[3] = 20;

   /* 
    * LL => Lower Left Start, CCW => Vertices entered in 
    * counter clockwise progression 
    */
   drawPolygon( 4, x, y );	/* Square, LL, CCW */

   x[0] = 40; y[0] = 30;
   x[1] = 40; y[1] = 50;
   x[2] = 30; y[2] = 50;
   x[3] = 30; y[3] = 30;

   drawPolygon( 4, x, y );	/* Rectangle, LR, CCW */

   x[0] = 40; y[0] = 90;
   x[1] = 40; y[1] = 70;
   x[2] = 10; y[2] = 70;
   x[3] = 10; y[3] = 90;

   drawPolygon( 4, x, y );	/* Rectangle, UR, CW */

   x[0] = 10; y[0] = 230;
   x[1] = 40; y[1] = 230;
   x[2] = 40; y[2] = 210;
   x[3] = 10; y[3] = 210;

   drawPolygon( 4, x, y );	/* Rectangle, UL, CW */

   x[0] = 100; y[0] = 10;
   x[1] = 150; y[1] = 10;
   x[2] = 125; y[2] = 20;

   drawPolygon( 3, x, y );	/* Isosceles, flat bottom */

   x[0] = 100; y[0] = 30;
   x[1] = 140; y[1] = 50;
   x[2] = 175; y[2] = 50;

   drawPolygon( 3, x, y );	/* flat top - tail to left */

   x[0] = 120; y[0] = 40;
   x[1] = 80;  y[1] = 60;
   x[2] = 45;  y[2] = 60;

   drawPolygon( 3, x, y );	/* flat top - tail to right */

   x[0] = 10; y[0] = 100;
   x[1] = 10; y[1] = 120;
   x[2] = 25; y[2] = 100;

   drawPolygon( 3, x, y );	/* Right */

   x[0] = 10; y[0] = 130;
   x[1] = 20; y[1] = 130;
   x[2] = 20; y[2] = 140;

   drawPolygon( 3, x, y );	/* Right */

   x[0] = 10; y[0] = 170;
   x[1] = 20; y[1] = 170;
   x[2] = 10; y[2] = 150;

   drawPolygon( 3, x, y );	/* Right */

   x[0] = 100; y[0] = 70;
   x[1] = 150; y[1] = 70;
   x[2] = 75;  y[2] = 90;

   drawPolygon( 3, x, y );	/* flat bottom - top left */

   x[0] = 100; y[0] = 100;
   x[1] = 150; y[1] = 100;
   x[2] = 195; y[2] = 120;

   drawPolygon( 3, x, y );	/* flat bottom - top right */

   x[0] = 100; y[0] = 170;
   x[1] = 150; y[1] = 150;
   x[2] = 175; y[2] = 130;

   drawPolygon( 3, x, y );	/* scalene */

   x[0] = 200; y[0] =  50;
   x[1] = 225; y[1] =  90;
   x[2] = 250; y[2] =  50;
   x[3] = 225; y[3] =  10;

   drawPolygon ( 4, x, y );     /* diamond */

   x[0] = 200; y[0] = 125;
   x[1] = 210; y[1] = 150;
   x[2] = 260; y[2] = 145;
   x[3] = 275; y[3] = 120;
   x[4] = 250; y[4] = 100;
   x[5] = 225; y[5] = 100;

   drawPolygon ( 6, x, y );     /* hexagon */

   x[0] = 215; y[0] = 225;
   x[1] = 200; y[1] = 250;
   x[2] = 215; y[2] = 250;
   x[3] = 225; y[3] = 275;
   x[4] = 235; y[4] = 250;
   x[5] = 250; y[5] = 250;
   x[6] = 235; y[6] = 225;

   drawPolygon ( 7, x, y );     /* star top */

   /* 
    * Flushs OpenGL commands to display 
    */
   glFlush();

}
Ejemplo n.º 7
0
//<<<<<<<<<<<<<<<<<<<<<<< myInit >>>>>>>>>>>>>>>>>>>>
 void myInit(void)
 {
	img = cv::imread("1.png");
	if(img.empty()) {
		printf("Error imread.\n");
		return ;
	}
	//cv::cvtColor(img, img, CV_BGR2RGB);
	
	glGenTextures(2, texId);
	CheckGlErrors("check glGenTextures");
	glBindTexture(GL_TEXTURE_2D, texId[0]);
	CheckGlErrors("check glBindTextures");
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img.cols, img.rows, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
	CheckGlErrors("check glTexImage2D");

#ifdef FBO
	img1 = cv::Mat(screenHeight, screenWidth, CV_8UC3);
	if(img1.empty()) {
		printf("Error create img1.\n");
		return ;
	}
	glBindTexture(GL_TEXTURE_2D, texId[1]);
	CheckGlErrors("check glBindTextures");
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img1.cols, img1.rows, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
	
	glGenFramebuffers(1, &fb);
	glBindFramebuffer(GL_FRAMEBUFFER, fb);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
		GL_TEXTURE_2D, texId[1], 0);
#endif

	GLint nModelViewMatrixCount = 0;
	GLint nProjectionMatrixCount = 0;

	glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &nModelViewMatrixCount);// 32
	glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &nProjectionMatrixCount); // 4
	printf("before, modelview matrix count %d, projection matrix count %d\n", nModelViewMatrixCount, nProjectionMatrixCount);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0.0, 1, 0.0, 1.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glViewport(0, 0, screenWidth, screenHeight);
	//glRotatef(90, 0, 0, -1);
	glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &nModelViewMatrixCount);// 32
	glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &nProjectionMatrixCount); // 4
	printf("after, modelview matrix count %d, projection matrix count %d\n", nModelViewMatrixCount, nProjectionMatrixCount);
	float mv_matrix[16];
	float projection_matrix[16];
	glGetFloatv(GL_MODELVIEW_MATRIX, mv_matrix);
	glGetFloatv(GL_PROJECTION_MATRIX, projection_matrix);
	printf("model view matrix\n");
	for(int i=0;i<16;++i) printf("%f ", mv_matrix[i]);
	printf("\n");
	printf("projection matrix\n");
	for(int i=0;i<16;++i) printf("%f ", projection_matrix[i]);
	printf("\n");
	CheckGlErrors("myInit()");

}
Ejemplo n.º 8
0
  void render(date renderDate)
  {
    assert(trailElements != NULL);

    Shader::Program::unUse();
    Texture::Unit::unUse();
    VBO::Element::unUse();
    FBO::list[FBO::trails].use();

    GLenum buffers[] = {
      GL_COLOR_ATTACHMENT0_EXT,
      GL_COLOR_ATTACHMENT1_EXT
    };

    oglDrawBuffers(1, buffers);

#if DEBUG_TRAILS
    glClearColor(0.1f, 0.1f, 0.1f, 1.f);
#else
    glClearColor(0, 0, 0, 1.f);
#endif // DEBUG_TRAILS

    glClear(GL_COLOR_BUFFER_BIT);

    glDisable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    glDisable( GL_LIGHTING );
    glDisable(GL_DEPTH_TEST);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0., 1., 0., 1.);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    /*
    {
      int i = 0;
      while (i < trailElements->size)
	if ((*trailElements)[i].birth + 500 < renderDate)
	{
	  trailElements->remove(i);
	}
	else
	{
	  ++i;
	}
    }
    */

#if DEBUG_TRAILS

    // Fond pour debugger
    glColor4f(0.4f, 0.4f, 0.4f, 0.4f);

    glBegin(GL_QUADS);
    glVertex2f(0.05f, 0.05f);
    glVertex2f(0.05f, 0.95f);
    glVertex2f(0.95f, 0.95f);
    glVertex2f(0.95f, 0.05f);
    glEnd();

#endif // DEBUG_TRAILS

    glEnableClientState(GL_VERTEX_ARRAY);

    Array<trailDesc> & list = (*trailElements);
    for (int i = 0; i < list.size; ++i)
    {
      const trailDesc & element = list[i];
      if (element.birth + 500 >= renderDate &&
	  element.birth <= renderDate)
      {
	renderElement(element, 0.002f * (renderDate - element.birth));
      }
    }

    glDisableClientState(GL_VERTEX_ARRAY);
  }
Ejemplo n.º 9
0
void CMiniMap::DrawForReal(bool use_geo)
{
	SCOPED_TIMER("MiniMap::DrawForReal");

	//glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glPushAttrib(GL_DEPTH_BUFFER_BIT);
	glDisable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glDepthMask(GL_FALSE);
	glDisable(GL_TEXTURE_2D);
	glMatrixMode(GL_MODELVIEW);

	if (minimized) {
		if (!slaveDrawMode) {
			DrawMinimizedButton();
		}
		glPopAttrib();
		glEnable(GL_TEXTURE_2D);
		return;
	}

	// draw the frameborder
	if (!slaveDrawMode && !globalRendering->dualScreenMode && !maximized) {
		glEnable(GL_BLEND);
		DrawFrame();
		glDisable(GL_BLEND);
	}


	bool resetTextureMatrix = false;

	if (use_geo) {
		glPushMatrix();

		// switch to normalized minimap coords
		if (globalRendering->dualScreenMode) {
			glViewport(xpos, ypos, width, height);
			glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f);
		} else {
			glTranslatef(xpos * globalRendering->pixelX, ypos * globalRendering->pixelY, 0.0f);
			glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f);
		}

		/* FIXME: fix mouse handling too and make it fully customizable, so Lua can rotate the minimap to any angle
		CCameraController* camController = &camHandler->GetCurrentController();
		COverheadController* taCam = dynamic_cast<COverheadController*>(camController);
		SmoothController* smCam = dynamic_cast<SmoothController*>(camController);

		if ((taCam && taCam->flipped) || (smCam && smCam->flipped)) {
			glTranslatef(1.0f, 1.0f, 0.0f);
			glScalef(-1.0f, -1.0f, 1.0f);

			glMatrixMode(GL_TEXTURE);
			glPushMatrix();
			glTranslatef(1.0f, 1.0f, 0.0f);
			glScalef(-1.0f, -1.0f, 1.0f);
			glMatrixMode(GL_MODELVIEW);

			resetTextureMatrix = true;
		}*/
	}

	setSurfaceCircleFunc(DrawSurfaceCircle);
	setSurfaceSquareFunc(DrawSurfaceSquare);
	cursorIcons.Enable(false);

	glColor4f(0.6f, 0.6f, 0.6f, 1.0f);

	// don't mirror the map texture with flipped cameras
	glMatrixMode(GL_TEXTURE);
	glPushMatrix();
	glLoadIdentity();
	glMatrixMode(GL_MODELVIEW);

	// draw the map
	glDisable(GL_BLEND);
		readmap->DrawMinimap();
	glEnable(GL_BLEND);

	glMatrixMode(GL_TEXTURE);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);

	// clip everything outside of the minimap box
	{
		const double plane0[4] = {0,-1,0,1};
		const double plane1[4] = {0,1,0,0};
		const double plane2[4] = {-1,0,0,1};
		const double plane3[4] = {1,0,0,0};

		glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom
		glClipPlane(GL_CLIP_PLANE1, plane1); // clip top
		glClipPlane(GL_CLIP_PLANE2, plane2); // clip right
		glClipPlane(GL_CLIP_PLANE3, plane3); // clip left

		glEnable(GL_CLIP_PLANE0);
		glEnable(GL_CLIP_PLANE1);
		glEnable(GL_CLIP_PLANE2);
		glEnable(GL_CLIP_PLANE3);
	}

	// switch to top-down map/world coords (z is twisted with y compared to the real map/world coords)
	glPushMatrix();
	glTranslatef(0.0f, +1.0f, 0.0f);
	glScalef(+1.0f / (gs->mapx * SQUARE_SIZE), -1.0f / (gs->mapy * SQUARE_SIZE), 1.0f);

	glEnable(GL_TEXTURE_2D);
	glEnable(GL_ALPHA_TEST);
	glAlphaFunc(GL_GREATER, 0.0f);

	{
		GML_RECMUTEX_LOCK(unit); // DrawForReal

		const std::set<CUnit*>& units = unitDrawer->GetUnsortedUnits();

		for (std::set<CUnit*>::const_iterator it = units.begin(); it != units.end(); ++it) {
			DrawUnit(*it);
		}

		// highlight the selected unit
		CUnit* unit = GetSelectUnit(GetMapPosition(mouse->lastx, mouse->lasty));
		if (unit != NULL) {
			DrawUnitHighlight(unit);
		}
	}

	glDisable(GL_ALPHA_TEST);
	glDisable(GL_TEXTURE_2D);

	glPushMatrix();
	glRotatef(-90.0f, +1.0f, 0.0f, 0.0f); // real 'world' coordinates
	glScalef(1.0f, 0.0f, 1.0f); // skip the y-coord (Lua's DrawScreen is perspective and so any z-coord in it influence the x&y, too)

	// draw the projectiles
	if (drawProjectiles) {
		glPointSize(1.0f);
		WorkaroundATIPointSizeBug();
		projectileDrawer->DrawProjectilesMiniMap();
	}

	// draw the queued commands
	//
	// NOTE: this needlessly adds to the CursorIcons list, but at least
	//       they are not drawn  (because the input receivers are drawn
	//       after the command queues)

	LuaUnsyncedCtrl::DrawUnitCommandQueues();
	if ((drawCommands > 0) && guihandler->GetQueueKeystate()) {
		selectedUnits.DrawCommands();
	}

	lineDrawer.DrawAll();

	// draw the selection shape, and some ranges
	if (drawCommands > 0) {
		guihandler->DrawMapStuff(!!drawCommands);
	}

	{
		GML_RECMUTEX_LOCK(sel); // DrawForReal

		// draw unit ranges
		const float radarSquare = radarhandler->radarDiv;
		CUnitSet& selUnits = selectedUnits.selectedUnits;
		for(CUnitSet::iterator si = selUnits.begin(); si != selUnits.end(); ++si) {
			CUnit* unit = *si;
			if (unit->radarRadius && !unit->beingBuilt && unit->activated) {
				glColor3fv(cmdColors.rangeRadar);
				DrawCircle(unit->pos, (unit->radarRadius * radarSquare));
			}
			if (unit->sonarRadius && !unit->beingBuilt && unit->activated) {
				glColor3fv(cmdColors.rangeSonar);
				DrawCircle(unit->pos, (unit->sonarRadius * radarSquare));
			}
			if (unit->jammerRadius && !unit->beingBuilt && unit->activated) {
				glColor3fv(cmdColors.rangeJammer);
				DrawCircle(unit->pos, (unit->jammerRadius * radarSquare));
			}
			// change if someone someday create a non stockpiled interceptor
			const CWeapon* w = unit->stockpileWeapon;
			if((w != NULL) && w->weaponDef->interceptor) {
				if (w->numStockpiled) {
					glColor3fv(cmdColors.rangeInterceptorOn);
				} else {
					glColor3fv(cmdColors.rangeInterceptorOff);
				}
				DrawCircle(unit->pos, w->weaponDef->coverageRange);
			}
		}
	}

	glPopMatrix(); // revert to the 2d xform

	if (!minimap->maximized) {
		// draw the camera frustum lines
		cam2->GetFrustumSides(0.0f, 0.0f, 1.0f, true);
		cam2->ClipFrustumLines(true, -10000.0f, 400096.0f);

		const std::vector<CCamera::FrustumLine>& negSides = cam2->negFrustumSides;
//		const std::vector<CCamera::FrustumLine>& posSides = cam2->posFrustumSides;
		std::vector<CCamera::FrustumLine>::const_iterator fli;

		CVertexArray* va = GetVertexArray();
		va->Initialize();
		va->EnlargeArrays(negSides.size() * 2, 0, VA_SIZE_2D0);

		for (fli = negSides.begin(); fli != negSides.end(); ++fli) {
			if (fli->minz < fli->maxz) {
				va->AddVertex2dQ0(fli->base + (fli->dir * fli->minz), fli->minz);
				va->AddVertex2dQ0(fli->base + (fli->dir * fli->maxz), fli->maxz);
			}
		}

		glLineWidth(2.5f);
		glColor4f(0, 0, 0, 0.5f);
		va->DrawArray2d0(GL_LINES);

		glLineWidth(1.5f);
		glColor4f(1, 1, 1, 0.75f);
		va->DrawArray2d0(GL_LINES);
		glLineWidth(1.0f);
	}


	// selection box
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	CMouseHandler::ButtonPressEvt& bp = mouse->buttons[SDL_BUTTON_LEFT];
	if (selecting && fullProxy && (bp.movement > 4)) {
		const float3 oldPos = GetMapPosition(bp.x, bp.y);
		const float3 newPos = GetMapPosition(mouse->lastx, mouse->lasty);
		glColor4fv(cmdColors.mouseBox);
		glBlendFunc((GLenum)cmdColors.MouseBoxBlendSrc(),
		            (GLenum)cmdColors.MouseBoxBlendDst());
		glLineWidth(cmdColors.MouseBoxLineWidth());

		float verts[] = {
			oldPos.x, oldPos.z,
			newPos.x, oldPos.z,
			newPos.x, newPos.z,
			oldPos.x, newPos.z,
		};
		glEnableClientState(GL_VERTEX_ARRAY);
		glVertexPointer(2, GL_FLOAT, 0, verts);
		glDrawArrays(GL_LINE_LOOP, 0, 4);
		glDisableClientState(GL_VERTEX_ARRAY);

		glLineWidth(1.0f);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	}

	DrawNotes();

	// reset 1
	if (resetTextureMatrix) {
		glMatrixMode(GL_TEXTURE_MATRIX);
		glPopMatrix();
	}
	glMatrixMode(GL_MODELVIEW);
	if (use_geo) {
		glPopMatrix();
	}

	// reset 2
	glPopMatrix();
	glPopAttrib();
	glEnable(GL_TEXTURE_2D);

	{
		//! prepare ClipPlanes for Lua's DrawInMinimap Modelview matrix

		//! quote from glClipPlane spec:
		//! "When glClipPlane is called, equation is transformed by the inverse of the modelview matrix and stored in the resulting eye coordinates.
		//!  Subsequent changes to the modelview matrix have no effect on the stored plane-equation components."
		//! -> we have to use the same modelview matrix when calling glClipPlane and later draw calls

		//! set the modelview matrix to the same as used in Lua's DrawInMinimap
		glPushMatrix();
		glLoadIdentity();
		glScalef(1.0f / width, 1.0f / height, 1.0f);

		const double plane0[4] = {0, -1, 0, double(height)};
		const double plane1[4] = {0, 1, 0, 0};
		const double plane2[4] = {-1, 0, 0, double(width)};
		const double plane3[4] = {1, 0, 0, 0};

		glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom
		glClipPlane(GL_CLIP_PLANE1, plane1); // clip top
		glClipPlane(GL_CLIP_PLANE2, plane2); // clip right
		glClipPlane(GL_CLIP_PLANE3, plane3); // clip left

		glPopMatrix();
	}

	//! allow the LUA scripts to draw into the minimap
	eventHandler.DrawInMiniMap();

	if (use_geo && globalRendering->dualScreenMode)
		glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);

	//FIXME: Lua modifies the matrices w/o reseting it! (quite complexe to fix because ClearMatrixStack() makes it impossible to use glPushMatrix)
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0,1,0,1);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	// disable ClipPlanes
	glDisable(GL_CLIP_PLANE0);
	glDisable(GL_CLIP_PLANE1);
	glDisable(GL_CLIP_PLANE2);
	glDisable(GL_CLIP_PLANE3);

	cursorIcons.Enable(true);
	setSurfaceCircleFunc(NULL);
	setSurfaceSquareFunc(NULL);
}
Ejemplo n.º 10
0
void klsMiniMap::setViewport() {
	// Set the projection matrix:	
	glMatrixMode (GL_PROJECTION);
	glLoadIdentity ();

	wxSize sz = GetClientSize();
	float minX = FLT_MAX, minY = FLT_MAX, maxX = -FLT_MAX, maxY = -FLT_MAX;
	hash_map < unsigned long, guiGate* >::iterator gateWalk = gateList->begin();
	while (gateWalk != gateList->end()) {
		float x, y;
		(gateWalk->second)->getGLcoords(x, y);
		if (x < minX) minX = x;
		if (y < minY) minY = y;
		if (x > maxX) maxX = x;
		if (y > maxY) maxY = y;
		gateWalk++;
	}
	if (origin.x < minX) minX = origin.x;
	if (origin.y > maxY) maxY = origin.y;
	if (endpoint.x > maxX) maxX = endpoint.x;
	if (endpoint.y < minY) minY = endpoint.y;

	minCorner = GLPoint2f(minX-5,maxY+5);
	maxCorner = GLPoint2f(maxX+5,minY-5);

	double screenAspect = (double) sz.GetHeight() / (double) sz.GetWidth();
	double mapWidth = maxCorner.x - minCorner.x;
	double mapHeight = minCorner.y - maxCorner.y; // max and min corner's defs are weird...
	
	GLPoint2f orthoBoxTL, orthoBoxBR;
	
	// If the map's width is the limiting factor:
	if( screenAspect * mapWidth >= mapHeight ) {
		// Fit to width:
		double imageHeight = screenAspect * mapWidth;

		// Set the ortho box width equal to the map width, and center the
		// height in the box:
		orthoBoxTL = GLPoint2f( minCorner.x, minCorner.y + 0.5*(imageHeight - mapHeight) );
		orthoBoxBR = GLPoint2f( maxCorner.x, maxCorner.y - 0.5*(imageHeight - mapHeight) );
	} else {
		// Fit to height:
		double imageWidth = mapHeight / screenAspect;

		// Set the ortho box height equal to the map height, and center the
		// width in the box:
		orthoBoxTL = GLPoint2f( minCorner.x - 0.5*(imageWidth - mapWidth), minCorner.y );
		orthoBoxBR = GLPoint2f( maxCorner.x + 0.5*(imageWidth - mapWidth), maxCorner.y );
	}

	// gluOrtho2D(left, right, bottom, top); (In world-space coords.)
	gluOrtho2D(orthoBoxTL.x, orthoBoxBR.x, orthoBoxBR.y, orthoBoxTL.y);
	glViewport(0, 0, (GLint) sz.GetWidth(), (GLint) sz.GetHeight());

	// Store minCorner and maxCorner for use in mouse handler:
	minCorner = orthoBoxTL;
	maxCorner = orthoBoxBR;

	// Set the model matrix:
	glMatrixMode (GL_MODELVIEW);
	glLoadIdentity ();
}
Ejemplo n.º 11
0
void CWorldDrawer::Draw()
{
	SCOPED_TIMER("WorldDrawer::Total");

	CBaseGroundDrawer* gd = readmap->GetGroundDrawer();

	if (globalRendering->drawSky) {
		sky->Draw();
	}

	if (globalRendering->drawGround) {
		SCOPED_TIMER("WorldDrawer::Terrain");
		gd->Draw(DrawPass::Normal);
		smoothHeightMeshDrawer->Draw(1.0f);
		treeDrawer->DrawGrass();
		gd->DrawTrees();
	}

	if (globalRendering->drawWater && !mapInfo->map.voidWater) {
		SCOPED_TIMER("WorldDrawer::Water");

		water->OcclusionQuery();
		if (water->IsDrawSolid()) {
			water->UpdateWater(game);
			water->Draw();
		}
	}

	selectedUnits.Draw();
	eventHandler.DrawWorldPreUnit();

	{
		SCOPED_TIMER("WorldDrawer::Models");
		DebugColVolDrawer::Draw();
		unitDrawer->Draw(false);
		modelDrawer->Draw();
		featureDrawer->Draw();
		pathDrawer->DrawAll();
	}

	//! transparent stuff
	glEnable(GL_BLEND);
	glDepthFunc(GL_LEQUAL);

	const bool noAdvShading = shadowHandler->shadowsLoaded;

	static const double plane_below[4] = {0.0f, -1.0f, 0.0f, 0.0f};
	static const double plane_above[4] = {0.0f,  1.0f, 0.0f, 0.0f};

	{
		glClipPlane(GL_CLIP_PLANE3, plane_below);
		glEnable(GL_CLIP_PLANE3);

		//! draw cloaked objects below water surface
		unitDrawer->DrawCloakedUnits(noAdvShading);
		featureDrawer->DrawFadeFeatures(noAdvShading);

		glDisable(GL_CLIP_PLANE3);
	}

	//! draw water
	if (globalRendering->drawWater && !mapInfo->map.voidWater) {
		SCOPED_TIMER("WorldDrawer::Water");

		if (!water->IsDrawSolid()) {
			//! Water rendering will overwrite features, so save them
			featureDrawer->SwapFeatures();
			water->UpdateWater(game);
			water->Draw();
			featureDrawer->SwapFeatures();
		}
	}

	{
		glClipPlane(GL_CLIP_PLANE3, plane_above);
		glEnable(GL_CLIP_PLANE3);

		//! draw cloaked objects above water surface
		unitDrawer->DrawCloakedUnits(noAdvShading);
		featureDrawer->DrawFadeFeatures(noAdvShading);

		glDisable(GL_CLIP_PLANE3);
	}

	{
		SCOPED_TIMER("WorldDrawer::Projectiles");
		projectileDrawer->Draw(false);
	}

	if (globalRendering->drawSky) {
		sky->DrawSun();
	}

	eventHandler.DrawWorld();

	LuaUnsyncedCtrl::DrawUnitCommandQueues();
	if (cmdColors.AlwaysDrawQueue() || guihandler->GetQueueKeystate()) {
		selectedUnits.DrawCommands();
	}

	lineDrawer.DrawAll();
	cursorIcons.Draw();
	cursorIcons.Clear();

	mouse->DrawSelectionBox();

	guihandler->DrawMapStuff(false);

	if (globalRendering->drawMapMarks && !game->hideInterface) {
		inMapDrawerView->Draw();
	}


	//! underwater overlay
	if (camera->pos.y < 0.0f) {
		glEnableClientState(GL_VERTEX_ARRAY);
		const float3& cpos = camera->pos;
		const float vr = globalRendering->viewRange * 0.5f;
		glDepthMask(GL_FALSE);
		glDisable(GL_TEXTURE_2D);
		glColor4f(0.0f, 0.5f, 0.3f, 0.50f);
		{
			float3 verts[] = {
				float3(cpos.x - vr, 0.0f, cpos.z - vr),
				float3(cpos.x - vr, 0.0f, cpos.z + vr),
				float3(cpos.x + vr, 0.0f, cpos.z + vr),
				float3(cpos.x + vr, 0.0f, cpos.z - vr)
			};
			glVertexPointer(3, GL_FLOAT, 0, verts);
			glDrawArrays(GL_QUADS, 0, 4);
		}

		{
			float3 verts[] = {
				float3(cpos.x - vr, 0.0f, cpos.z - vr),
				float3(cpos.x - vr,  -vr, cpos.z - vr),
				float3(cpos.x - vr, 0.0f, cpos.z + vr),
				float3(cpos.x - vr,  -vr, cpos.z + vr),
				float3(cpos.x + vr, 0.0f, cpos.z + vr),
				float3(cpos.x + vr,  -vr, cpos.z + vr),
				float3(cpos.x + vr, 0.0f, cpos.z - vr),
				float3(cpos.x + vr,  -vr, cpos.z - vr),
				float3(cpos.x - vr, 0.0f, cpos.z - vr),
				float3(cpos.x - vr,  -vr, cpos.z - vr),
			};
			glVertexPointer(3, GL_FLOAT, 0, verts);
			glDrawArrays(GL_QUAD_STRIP, 0, 10);
		}

		glDepthMask(GL_TRUE);
		glDisableClientState(GL_VERTEX_ARRAY);
	}

	//reset fov
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0,1,0,1);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glEnable(GL_BLEND);
	glDisable(GL_DEPTH_TEST);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	// underwater overlay, part 2
	if (camera->pos.y < 0.0f) {
		glEnableClientState(GL_VERTEX_ARRAY);
		glDisable(GL_TEXTURE_2D);
		glColor4f(0.0f, 0.2f, 0.8f, 0.333f);
		float3 verts[] = {
			float3 (0.f, 0.f, -1.f),
			float3 (1.f, 0.f, -1.f),
			float3 (1.f, 1.f, -1.f),
			float3 (0.f, 1.f, -1.f),
		};
		glVertexPointer(3, GL_FLOAT, 0, verts);
		glDrawArrays(GL_QUADS, 0, 4);
		glDisableClientState(GL_VERTEX_ARRAY);
	}
}
Ejemplo n.º 12
0
/* Draws the string on the window at the given pixel position.
   Newlines and tab stops are honored.
   Any text inside [] will be rendered as a subscript.
   Assumes the font has been loaded as with load_font().
 */
void
print_gl_string (Display *dpy,
                 XFontStruct *font,
                 GLuint font_dlist,
                 int window_width, int window_height,
                 GLfloat x, GLfloat y,
                 const char *string,
                 Bool clear_background_p)
{
    GLfloat line_height = font->ascent + font->descent;
    GLfloat sub_shift = (line_height * 0.3);
    int cw = string_width (font, "m", 0);
    int tabs = cw * 7;

    y -= line_height;

    /* Sadly, this causes a stall of the graphics pipeline (as would the
       equivalent calls to glGet*.)  But there's no way around this, short
       of having each caller set up the specific display matrix we need
       here, which would kind of defeat the purpose of centralizing this
       code in one file.
     */
    glPushAttrib (GL_TRANSFORM_BIT |  /* for matrix contents */
                  GL_ENABLE_BIT |     /* for various glDisable calls */
                  GL_CURRENT_BIT |    /* for glColor3f() */
                  GL_LIST_BIT);       /* for glListBase() */
    {
# ifdef DEBUG
        check_gl_error ("glPushAttrib");
# endif

        /* disable lighting and texturing when drawing bitmaps!
           (glPopAttrib() restores these.)
         */
        glDisable (GL_TEXTURE_2D);
        glDisable (GL_LIGHTING);
        glDisable (GL_BLEND);
        glDisable (GL_DEPTH_TEST);
        glDisable (GL_CULL_FACE);

        /* glPopAttrib() does not restore matrix changes, so we must
           push/pop the matrix stacks to be non-intrusive there.
         */
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        {
# ifdef DEBUG
            check_gl_error ("glPushMatrix");
# endif
            glLoadIdentity();

            /* Each matrix mode has its own stack, so we need to push/pop
               them separately. */
            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            {
                unsigned int i;
                int x2 = x;
                Bool sub_p = False;

# ifdef DEBUG
                check_gl_error ("glPushMatrix");
# endif

                glLoadIdentity();
                gluOrtho2D (0, window_width, 0, window_height);
# ifdef DEBUG
                check_gl_error ("gluOrtho2D");
# endif

                if (clear_background_p)
                {
                    int w, h;
                    int lh = font->ascent + font->descent;
                    w = string_width (font, string, &h);
                    glColor3f (0, 0, 0);
                    glRecti (x - font->descent,
                             y + lh,
                             x + w + 2*font->descent,
                             y + lh - h - font->descent);
                    glColor3f (1, 1, 1);
                }

                /* draw the text */
                glRasterPos2f (x, y);
                /*        glListBase (font_dlist);*/
                for (i = 0; i < strlen(string); i++)
                {
                    unsigned char c = (unsigned char) string[i];
                    if (c == '\n')
                    {
                        glRasterPos2f (x, (y -= line_height));
                        x2 = x;
                    }
                    else if (c == '\t')
                    {
                        x2 -= x;
                        x2 = ((x2 + tabs) / tabs) * tabs;  /* tab to tab stop */
                        x2 += x;
                        glRasterPos2f (x2, y);
                    }
                    else if (c == '[' && (isdigit (string[i+1])))
                    {
                        sub_p = True;
                        glRasterPos2f (x2, (y -= sub_shift));
                    }
                    else if (c == ']' && sub_p)
                    {
                        sub_p = False;
                        glRasterPos2f (x2, (y += sub_shift));
                    }
                    else
                    {
                        /*            glCallLists (s - string, GL_UNSIGNED_BYTE, string);*/
                        glCallList (font_dlist + (int)(c));
                        x2 += (font->per_char
                               ? font->per_char[c - font->min_char_or_byte2].width
                               : font->min_bounds.width);
                    }
                }
# ifdef DEBUG
                check_gl_error ("print_gl_string");
# endif
            }
            glPopMatrix();
        }
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
    }
    glPopAttrib();
# ifdef DEBUG
    check_gl_error ("glPopAttrib");
# endif

    glMatrixMode(GL_MODELVIEW);
}
Ejemplo n.º 13
0
//----------
// 表示関数
//----------
void display( void )
{
	glClear( GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );

	glDisable( GL_CULL_FACE );
	glDisable( GL_ALPHA_TEST );
	glDisable( GL_BLEND );

	g_clARTK.display();

	glEnable( GL_CULL_FACE );
	glEnable( GL_ALPHA_TEST );
	glEnable( GL_BLEND );

	if( g_clARTK.isMarkerFound() )
	{
		double	dMat[16];

		glMatrixMode( GL_PROJECTION );
		g_clARTK.getProjectionMat( dMat );
		glLoadMatrixd( dMat );

		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity();

		glPushMatrix();

			g_clARTK.getModelViewMat( dMat );
			glLoadMatrixd( dMat );

			glScalef( 1.0f, 1.0f, -1.0f );	// 左手系 → 右手系
			g_clPMDModel.render();

			// ステンシルバッファに影の形を描画
			glDisable( GL_CULL_FACE );
			glDisable( GL_TEXTURE_2D );
			glDisable( GL_LIGHTING );

			glEnable( GL_STENCIL_TEST );
			glStencilFunc( GL_ALWAYS, 1, ~0 );
			glStencilOp( GL_REPLACE, GL_KEEP, GL_REPLACE );

			glColorMask( 0, 0, 0, 0 );
			glDepthMask( 0 );

				glMultMatrixf( (const float *)g_matPlanarProjection );
				g_clPMDModel.renderForShadow();		// 影用の描画

			glColorMask( 1, 1, 1, 1 );

			// ステンシルバッファの影の形を塗りつぶす
			float	fWndW = glutGet( GLUT_WINDOW_WIDTH ),
					fWndH = glutGet( GLUT_WINDOW_HEIGHT );

			glStencilFunc( GL_EQUAL, 1, ~0);
			glStencilOp( GL_KEEP, GL_KEEP ,GL_KEEP );

			glDisable( GL_DEPTH_TEST );

			glMatrixMode( GL_PROJECTION );
			glPushMatrix();
			glLoadIdentity();
			gluOrtho2D( 0.0f, fWndW, 0.0f, fWndH );

			glMatrixMode( GL_MODELVIEW );
			glPushMatrix();
			glLoadIdentity();

				glColor4f( 0.2f, 0.2f, 0.2f, 0.5f );

				glBegin( GL_TRIANGLE_FAN );
					glVertex2f(  0.0f, fWndH );
					glVertex2f( fWndW, fWndH );
					glVertex2f( fWndW,  0.0f );
					glVertex2f(  0.0f,  0.0f );
				glEnd();

			glMatrixMode( GL_PROJECTION );
			glPopMatrix();
			glMatrixMode( GL_MODELVIEW );
			glPopMatrix();

			glDepthMask( 1 );
			glEnable( GL_LIGHTING );
			glEnable( GL_DEPTH_TEST );
			glDisable( GL_STENCIL_TEST );

		glPopMatrix();
	}

	calcFps();

	glutSwapBuffers();
}