Beispiel #1
0
void draw_minimap_title_bar(window_info *win)
{
#ifdef	NEW_TEXTURES
	float u_first_start= (float)31/255;
	float u_first_end = 0.0f;
	float v_first_start = (float)160/255;
	float v_first_end = (float)175/255;

	float u_last_start = 0.0f;
	float u_last_end = (float)31/255;
	float v_last_start = (float)160/255;
	float v_last_end = (float)175/255;
#else	/* NEW_TEXTURES */
	float u_first_start= (float)31/255;
	float u_first_end= 0;
	float v_first_start= 1.0f-(float)160/255;
	float v_first_end= 1.0f-(float)175/255;

	float u_last_start= 0;
	float u_last_end= (float)31/255;
	float v_last_start= 1.0f-(float)160/255;
	float v_last_end= 1.0f-(float)175/255;
#endif	/* NEW_TEXTURES */

	int close_button_x = win->len_x/2 + 32 - 1;

	glPushMatrix();

	glColor3f(1.0f,1.0f,1.0f);
	
#ifdef	NEW_TEXTURES
	bind_texture(icons_text);
#else	/* NEW_TEXTURES */
	get_and_set_texture_id(icons_text);
#endif	/* NEW_TEXTURES */
	glEnable(GL_ALPHA_TEST);
	glAlphaFunc(GL_GREATER,0.03f);
	glEnable(GL_TEXTURE_2D);

	glBegin(GL_QUADS);

	glTexCoord2f(u_first_end, v_first_start);
	glVertex3i(win->len_x/2-32, ELW_TITLE_HEIGHT, 0);
	glTexCoord2f(u_first_end, v_first_end);
	glVertex3i(win->len_x/2-32, 0, 0);
	glTexCoord2f(u_first_start, v_first_end);
	glVertex3i(win->len_x/2, 0, 0);
	glTexCoord2f(u_first_start, v_first_start);
	glVertex3i(win->len_x/2, ELW_TITLE_HEIGHT, 0);

	glTexCoord2f(u_last_end, v_last_start);
	glVertex3i(win->len_x/2, ELW_TITLE_HEIGHT, 0);
	glTexCoord2f(u_last_end, v_last_end);
	glVertex3i(win->len_x/2, 0, 0);
	glTexCoord2f(u_last_start, v_last_end);
	glVertex3i(win->len_x/2+32, 0, 0);
	glTexCoord2f(u_last_start, v_last_start);
	glVertex3i(win->len_x/2+32, ELW_TITLE_HEIGHT, 0);
	
	glEnd();
	glDisable(GL_ALPHA_TEST);
	glDisable(GL_TEXTURE_2D);

	//draw the X background
	glColor3f(0.156f,0.078f,0.0f);
	glBegin(GL_POLYGON);
		glVertex2f(close_button_x + ELW_TITLE_HEIGHT, ELW_TITLE_HEIGHT);
		glVertex2f(close_button_x, ELW_TITLE_HEIGHT);
		glVertex2f(close_button_x, 0);
		glVertex2f(close_button_x + ELW_TITLE_HEIGHT, 0);
	glEnd();
	//draw the rectngle
	glColor3f(win->line_color[0],win->line_color[1],win->line_color[2]);
	glBegin(GL_LINE_STRIP);
		glVertex2i(close_button_x + ELW_TITLE_HEIGHT-2 - gx_adjust, ELW_TITLE_HEIGHT-1 - gy_adjust);
		glVertex2i(close_button_x + 1 - gx_adjust, ELW_TITLE_HEIGHT-1 - gy_adjust);
		glVertex2i(close_button_x + 1 - gx_adjust, 2 - gy_adjust);
		glVertex2i(close_button_x + ELW_TITLE_HEIGHT-2 - gx_adjust, 2 - gy_adjust);
		glVertex2i(close_button_x + ELW_TITLE_HEIGHT-2 - gx_adjust, ELW_TITLE_HEIGHT-1 - gy_adjust);
	glEnd();
	//draw the X
	glLineWidth(2.0f);
	glBegin(GL_LINES);
		glVertex2i(close_button_x + 3, 4);
		glVertex2i(close_button_x + ELW_TITLE_HEIGHT-3, ELW_TITLE_HEIGHT-4);
		glVertex2i(close_button_x + ELW_TITLE_HEIGHT-3, 4);
		glVertex2i(close_button_x + 3, ELW_TITLE_HEIGHT-4);
	glEnd();

	glLineWidth(1.0f);

	glPopMatrix();
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
Beispiel #2
0
void DrawBloomTex(int winW,int winH)
{
		
		glBindTexture(GL_TEXTURE_2D, bloomTexId2);

		glDisable(GL_BLEND);	
		glDisable(GL_DEPTH_TEST);							// Disables Depth Testing
		glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
		glPushMatrix();										// Store The Projection Matrix
		glLoadIdentity();									// Reset The Projection Matrix
		glOrtho(-winW/2,winW/2,-winH/2,winH/2,-1,1);							// Set Up An Ortho Screen
		glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
		glPushMatrix();										// Store The Modelview Matrix
		glLoadIdentity();	


			DrawBloomMap(winW,winH);
			glBegin(GL_QUADS);
				glTexCoord2f(0.0f,0.0f);glVertex2i(-DrawbloomTexSize/2,-DrawbloomTexSize/2);
				glTexCoord2f(1.0f,0.0f);glVertex2i( DrawbloomTexSize/2,-DrawbloomTexSize/2);
				glTexCoord2f(1.0f,1.0f);glVertex2i( DrawbloomTexSize/2, DrawbloomTexSize/2);
				glTexCoord2f(0.0f,1.0f);glVertex2i(-DrawbloomTexSize/2, DrawbloomTexSize/2);
			glEnd();
			CGDisableProfilePixel();
			glBindTexture(GL_TEXTURE_2D, bloomTexId1);
			glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, -(DrawbloomTexSize-winW)/2, -(DrawbloomTexSize-winH)/2, DrawbloomTexSize, DrawbloomTexSize, 0);
			//glClear (GL_COLOR_BUFFER_BIT );

			DrawBloomW(winW);
			glBegin(GL_QUADS);
				glTexCoord2f(0.0f,0.0f);glVertex2i(-DrawbloomTexSize/2,-DrawbloomTexSize/2);
				glTexCoord2f(1.0f,0.0f);glVertex2i( DrawbloomTexSize/2,-DrawbloomTexSize/2);
				glTexCoord2f(1.0f,1.0f);glVertex2i( DrawbloomTexSize/2, DrawbloomTexSize/2);
				glTexCoord2f(0.0f,1.0f);glVertex2i(-DrawbloomTexSize/2, DrawbloomTexSize/2);
			glEnd();
			CGDisableProfilePixel();
			glBindTexture(GL_TEXTURE_2D, bloomTexId1);
			glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, -(DrawbloomTexSize-winW)/2, -(DrawbloomTexSize-winH)/2, DrawbloomTexSize, DrawbloomTexSize, 0);
			//glClear (GL_COLOR_BUFFER_BIT );

			DrawBloomH(winH);
			glBegin(GL_QUADS);
				glTexCoord2f(0.0f,0.0f);glVertex2i(-DrawbloomTexSize/2,-DrawbloomTexSize/2);
				glTexCoord2f(1.0f,0.0f);glVertex2i( DrawbloomTexSize/2,-DrawbloomTexSize/2);
				glTexCoord2f(1.0f,1.0f);glVertex2i( DrawbloomTexSize/2, DrawbloomTexSize/2);
				glTexCoord2f(0.0f,1.0f);glVertex2i(-DrawbloomTexSize/2, DrawbloomTexSize/2);
			glEnd();
			CGDisableProfilePixel();
			glBindTexture(GL_TEXTURE_2D, bloomTexId1);
			glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, -(DrawbloomTexSize-winW)/2, -(DrawbloomTexSize-winH)/2, DrawbloomTexSize, DrawbloomTexSize, 0);
			//glClear (GL_COLOR_BUFFER_BIT );
			
		glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
		glPopMatrix();										// Restore The Old Projection Matrix
		glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
		glPopMatrix();										// Restore The Old Projection Matrix
		glEnable(GL_DEPTH_TEST);							// Enables Depth Testing

		glEnable(GL_BLEND);
	
}
Beispiel #3
0
void Blur_apply(){
	
	if(multiSamples!=1 && blur==Blur_glsl_depth){
		consoleLog("Blur_apply: Blur_glsl_depth can't be used with multisample, disabling\n");
		blur=Blur_glsl_simple;
	}
	
	if(blur==Blur_none)
		return;
	
	float lastMatrix[16];
	glGetFloatv(GL_MODELVIEW_MATRIX, lastMatrix);
	
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();
	glScalef(2.f/screen->w, -2.f/screen->h, 1.f);
	glTranslatef(-screen->w*.5f, -screen->h*.5f, 0.f);
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_FOG);
	glDisable(GL_LIGHTING);
	glDepthMask(GL_FALSE);
	
	if(blur==Blur_basic){
		
		glColor4f(1.f, 1.f, 1.f, powf(.3f, blurdt*60.f));
		glBindTexture(GL_TEXTURE_2D, tex_screen);
		glBegin(GL_QUADS);
		glTexCoord2f(0.f, (float)screen->h/sh);
		glVertex2i(0, 0);
		glTexCoord2f(0.f, 0.f);
		glVertex2i(0, screen->h);
		glTexCoord2f((float)screen->w/sw, 0.f);
		glVertex2i(screen->w, screen->h);
		glTexCoord2f((float)screen->w/sw, (float)screen->h/sh);
		glVertex2i(screen->w, 0);
		glEnd();
		
		totalPolys+=2;
		
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
	}
#if GL_ARB_shader_objects
	else if(blur==Blur_glsl_simple){
		glUseProgramObjectARB(prg_blurSimple);
		glUniform1iARB(glGetUniformLocationARB(prg_blurSimple, "screen"),
					   0);
		glUniform2fARB(glGetUniformLocationARB(prg_blurSimple, "texSize"),
					   (float)screen->w/sw, (float)screen->h/sh);
		float imat[16];
		float mat2[16];
		memcpy(imat, mx_old, sizeof(imat));
		inverseMatrix4(imat);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrix"),
							  1, GL_FALSE, lastMatrix);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrix"),
							  1, GL_FALSE, mx_old);
		inverseMatrix4(lastMatrix);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrixInverse"),
					   1, GL_FALSE, imat);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrixInverse"),
							  1, GL_FALSE, lastMatrix);
		glColor4f(1,1,1,1);
		glBindTexture(GL_TEXTURE_2D, tex_screen);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
		glBegin(GL_QUADS);
		glTexCoord2f(-1.f, 1.f);
		glVertex2i(0, 0);
		glTexCoord2f(-1.f, -1.f);
		glVertex2i(0, screen->h);
		glTexCoord2f(1.f, -1.f);
		glVertex2i(screen->w, screen->h);
		glTexCoord2f(1.f, 1.f);
		glVertex2i(screen->w, 0);
		glEnd();
		totalPolys+=2;
		glUseProgramObjectARB(0);
	}
#if GL_ARB_depth_texture
	else if(blur==Blur_glsl_depth){
		
		glActiveTexture(GL_TEXTURE1_ARB);
		glBindTexture(GL_TEXTURE_2D, tex_depth);
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
		glActiveTexture(GL_TEXTURE0_ARB);
		
		glUseProgramObjectARB(prg_blurDepth);
		glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "screen"),
					   0);
		glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "depthTex"),
					   1);
		glUniform2fARB(glGetUniformLocationARB(prg_blurDepth, "texSize"),
					   (float)screen->w/sw, (float)screen->h/sh);
		float imat[16];
		float mat2[16];
		memcpy(imat, mx_old, sizeof(imat));
		inverseMatrix4(imat);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrix"),
							  1, GL_FALSE, lastMatrix);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrix"),
							  1, GL_FALSE, mx_old);
		inverseMatrix4(lastMatrix);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrixInverse"),
							  1, GL_FALSE, imat);
		glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrixInverse"),
							  1, GL_FALSE, lastMatrix);
		glColor4f(1,1,1,1);
		glBindTexture(GL_TEXTURE_2D, tex_screen);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
		glBegin(GL_QUADS);
		glTexCoord2f(-1.f, 1.f);
		glVertex2i(0, 0);
		glTexCoord2f(-1.f, -1.f);
		glVertex2i(0, screen->h);
		glTexCoord2f(1.f, -1.f);
		glVertex2i(screen->w, screen->h);
		glTexCoord2f(1.f, 1.f);
		glVertex2i(screen->w, 0);
		glEnd();
		totalPolys+=2;
		glUseProgramObjectARB(0);
	}
#endif
#endif
	
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_LIGHTING);
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_FOG);
	glDepthMask(GL_TRUE);
	
}
Beispiel #4
0
static void hw_draw_extra_shape(struct TileWindow *win, 
    struct ExtraShape *shape)
{
  int sx, sy, sw, sh;
  int size;

  sw = win->scale_w;
  sh = win->scale_h;

  sx = win->scr_x - win->pan_x + shape->x * sw + shape->y * win->scale_skew;
  sy = win->scr_y - win->pan_y + shape->y * sh;
   
  /* trivial clipping */
  if (sx + sw <= win->scr_x || sx >= win->scr_x + win->scr_w)
    return;

  if (sy + sh * 2 <= win->scr_y || sy >= win->scr_y + win->scr_h)
    return;

  switch (shape->type)
  {
    case SHAPE_None:
      break;

    case SHAPE_Heart:
    case SHAPE_Ridden:
      /* 
       * par1: 0 is normal, 1 puts it on the left.
       */
      sx += win->scale_full_w * (shape->par1 ? 1 : 3) / 4;

      size = (win->scale_h <= 10) ? 6 : 8;

      if (win->scale_h > 24)
        size += (win->scale_h - 24) / 4;

      sy += (win->scale_full_h - sh) * 3 / 5;

      if (win->scale_h < 16)
        sy += 4;

      sx -= size / 2;

      glEnable(GL_TEXTURE_2D);

      if (shape->type == SHAPE_Ridden)
        glBindTexture(GL_TEXTURE_2D, ridden_mark_id);
      else
        glBindTexture(GL_TEXTURE_2D, pet_mark_id);

      glColor3f(1.0, 1.0, 1.0);
      glEnable(GL_BLEND);

      glBegin(GL_QUADS);
      glTexCoord2f(0.01, 0.01);  glVertex2i(sx, sy+sh-size);
      glTexCoord2f(0.01, 0.99);  glVertex2i(sx, sy+sh);
      glTexCoord2f(0.99, 0.99);  glVertex2i(sx+size, sy+sh);
      glTexCoord2f(0.99, 0.01);  glVertex2i(sx+size, sy+sh-size);
      glEnd();
      
      glDisable(GL_TEXTURE_2D);
      glDisable(GL_BLEND);
      break;
  }
}
Beispiel #5
0
void render(Game *game)
{
    float w, h;
    Rect r;
    glClear(GL_COLOR_BUFFER_BIT);
    r.bot = WINDOW_HEIGHT - 20;
    r.left = 10;
    r.center = 0;
    ggprint8b(&r, 16, 0x00FFFFFF, "Waterfall Model");
    //Draw shapes...

    const int n=40;
    static int firsttime = 1;
    static Vec vert[n];
    if (firsttime) {
        float ang = 0.0, inc = (3.14159 * 2.0) / (float)n;
        for (int i = 0; i<n; i++) {
            vert[i].x = cos(ang) * game->circle.radius;
            vert[i].y = sin(ang) * game->circle.radius;
            ang += inc;
        }
        firsttime = 0;
    glColor3ub(90,140,90);
    }

    //draw circle
    glColor3ub(90,140,90);
    glBegin(GL_LINE_LOOP);
    glColor3ub(90,140,90);
    for (int i = 0; i < n; i++) {
        glVertex2i(game->circle.center.x + vert[i].x, game->circle.center.y + vert[i].y);
    }
    glEnd();

    //draw box
    Shape *s;
    glColor3ub(90,140,90);
    
    const char* text[5] = {"Requirements", "Design", "Coding", "Testing", "Maintenance"};
    
    for (int i = 0; i < 5; i++) {
    glColor3ub(90,140,90);
    
    r.bot = WINDOW_HEIGHT - (110 + (i * 60));
    r.left = (60 + (i * 70));
    r.center = 0;

    s = &game->box[i];
    glPushMatrix();
    glTranslatef(s->center.x, s->center.y, s->center.z);
    w = s->width;
    h = s->height;
    glBegin(GL_QUADS);
    glVertex2i(-w,-h);
    glVertex2i(-w, h);
    glVertex2i( w, h);
    glVertex2i( w,-h);
    glEnd();
    glPopMatrix();
    
    ggprint8b(&r, 16, 0x00F3FF00, text[i]); //0x00ff0000
    
    }

    //draw all particles here
    glPushMatrix();
    glColor3ub(150,160,220);
    for (int i = 0; i < game->n; i++) {
    Vec *c = &game->particle[i].s.center;
    w = 2;
    h = 2;
    glBegin(GL_QUADS);
    glVertex2i(c->x-w, c->y-h);
    glVertex2i(c->x-w, c->y+h);
    glVertex2i(c->x+w, c->y+h);
    glVertex2i(c->x+w, c->y-h);
    glEnd();
    }
    glPopMatrix();
}
void Timer::draw()
	{
	glBegin( GL_QUADS );
		// top
		Color(0.333).scaleValue( 0.75 ).withAlpha( 0.75 ).set();
		glVertex2i( 0, 0 );
		glVertex2i( bounds.w, 0 );

		// bottom
		Color(0.333).scaleValue( 0.25 ).withAlpha( 0.5 ).set();
		glVertex2i( bounds.w, bounds.h );
		glVertex2i( 0, bounds.h );
	glEnd();

	if ( enabled())
		{
		// draw pulsing Pause symbol
		Color(0.333).scaleValue( m_ticks & 1 ? 0.8 : 1.0 ).withAlpha(0.5).set();
		glBegin( GL_QUADS );
			glVertex2i( 7, 7 );
			glVertex2i( 13, 7 );
			glVertex2i( 13, 23 );
			glVertex2i( 7, 23 );
			// prime numbers are good!
			glVertex2i( 17, 7 );
			glVertex2i( 23, 7 );
			glVertex2i( 23, 23 );
			glVertex2i( 17, 23 );
		glEnd();
		}
	else
		{
		// draw Run symbol
		Color(0.333).withAlpha(0.5).set();
		glBegin( GL_TRIANGLES );
			glVertex2i( 8, 5 );
			glVertex2i( 23, 15 );
			glVertex2i( 8, 24 );
		glEnd();

		Color(0.333).set();
		glEnable( GL_LINE_SMOOTH );
		glBegin( GL_LINE_LOOP );
			glVertex2i( 8, 5 );
			glVertex2i( 23, 15 );
			glVertex2i( 8, 24 );
		glEnd();
		glDisable( GL_LINE_SMOOTH );
		}

	glColor4f( 0, 0, 0, 0.5 );
	localRect().stroke();
	}
Beispiel #7
0
void render(void)
{
	Rect r;

	//Clear the screen
	glClearColor(1.0, 1.0, 1.0, 1.0);
	glClear(GL_COLOR_BUFFER_BIT);

	//
	//
	//draw a quad with texture
	float wid = 120.0f;
	glColor3f(1.0, 1.0, 1.0);
	if (forest) {
		glBindTexture(GL_TEXTURE_2D, forestTexture);
		glBegin(GL_QUADS);
			glTexCoord2f(0.0f, 1.0f); glVertex2i(0, 0);
			glTexCoord2f(0.0f, 0.0f); glVertex2i(0, yres);
			glTexCoord2f(1.0f, 0.0f); glVertex2i(xres, yres);
			glTexCoord2f(1.0f, 1.0f); glVertex2i(xres, 0);
		glEnd();
	}
	if (show_bigfoot) {
		glPushMatrix();
		glTranslatef(bigfoot.pos[0], bigfoot.pos[1], bigfoot.pos[2]);
		if (!silhouette) {
			glBindTexture(GL_TEXTURE_2D, bigfootTexture);
		} else {
			glBindTexture(GL_TEXTURE_2D, silhouetteTexture);
			glEnable(GL_ALPHA_TEST);
			glAlphaFunc(GL_GREATER, 0.0f);
			glColor4ub(255,255,255,255);
		}
		glBegin(GL_QUADS);
			if (bigfoot.vel[0] > 0.0) {
				glTexCoord2f(0.0f, 1.0f); glVertex2i(-wid,-wid);
				glTexCoord2f(0.0f, 0.0f); glVertex2i(-wid, wid);
				glTexCoord2f(1.0f, 0.0f); glVertex2i( wid, wid);
				glTexCoord2f(1.0f, 1.0f); glVertex2i( wid,-wid);
			} else {
				glTexCoord2f(1.0f, 1.0f); glVertex2i(-wid,-wid);
				glTexCoord2f(1.0f, 0.0f); glVertex2i(-wid, wid);
				glTexCoord2f(0.0f, 0.0f); glVertex2i( wid, wid);
				glTexCoord2f(0.0f, 1.0f); glVertex2i( wid,-wid);
			}
		glEnd();
		glPopMatrix();
		//
		if (trees && silhouette) {
			glBindTexture(GL_TEXTURE_2D, forestTransTexture);
			glBegin(GL_QUADS);
				glTexCoord2f(0.0f, 1.0f); glVertex2i(0, 0);
				glTexCoord2f(0.0f, 0.0f); glVertex2i(0, yres);
				glTexCoord2f(1.0f, 0.0f); glVertex2i(xres, yres);
				glTexCoord2f(1.0f, 1.0f); glVertex2i(xres, 0);
			glEnd();
		}
		glDisable(GL_ALPHA_TEST);
	}

	glDisable(GL_TEXTURE_2D);
	//glColor3f(1.0f, 0.0f, 0.0f);
	//glBegin(GL_QUADS);
	//	glVertex2i(10,10);
	//	glVertex2i(10,60);
	//	glVertex2i(60,60);
	//	glVertex2i(60,10);
	//glEnd();
	//return;
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	if (show_rain)
		draw_raindrops();
	glDisable(GL_BLEND);
	glEnable(GL_TEXTURE_2D);
	//
	#ifdef USE_UMBRELLA
	if (show_umbrella)
		draw_umbrella();
	#endif //USE_UMBRELLA
	glBindTexture(GL_TEXTURE_2D, 0);
	//
	//
	r.bot = yres - 20;
	r.left = 10;
	r.center = 0;
	unsigned int cref = 0x00ffffff;
	ggprint8b(&r, 16, cref, "B - Bigfoot");
	ggprint8b(&r, 16, cref, "F - Forest");
	ggprint8b(&r, 16, cref, "S - Silhouette");
	ggprint8b(&r, 16, cref, "T - Trees");
	ggprint8b(&r, 16, cref, "U - Umbrella");
	ggprint8b(&r, 16, cref, "R - Rain");
	ggprint8b(&r, 16, cref, "D - Deflection");
	ggprint8b(&r, 16, cref, "N - Sounds");
}
Beispiel #8
0
void Route::DrawGL( ViewPort &VP )
{
#ifdef ocpnUSE_GL
    if( m_nPoints < 1 || !m_bVisible ) return;

    //  Hiliting first
    //  Being special case to draw something for a 1 point route....
    ocpnDC dc;
    if(m_hiliteWidth) {
        wxColour y = GetGlobalColor( _T ( "YELO1" ) );
        wxColour hilt( y.Red(), y.Green(), y.Blue(), 128 );

        wxPen HiPen( hilt, m_hiliteWidth, wxPENSTYLE_SOLID );

        ocpnDC dc;
        dc.SetPen( HiPen );

        wxRoutePointListNode *node = pRoutePointList->GetFirst();
        RoutePoint *prp0 = node->GetData();
        wxPoint r0;

        bool r0valid = cc1->GetCanvasPointPix( prp0->m_lat, prp0->m_lon, &r0);

        int lines = 0;
        node = node->GetNext();
        while( node ) {

            RoutePoint *prp = node->GetData();
            wxPoint r1;
            bool r1valid = cc1->GetCanvasPointPix( prp->m_lat, prp->m_lon, &r1);

            if(r0valid && r1valid) {
                dc.StrokeLine( r0.x, r0.y, r1.x, r1.y );
                lines++;
            }

            r0valid = r1valid;
            r0 = r1;
            node = node->GetNext();

        }

        if(lines == 0 &&
                cc1->GetCanvasPointPix( prp0->m_lat, prp0->m_lon, &r0)) {
            dc.StrokeLine( r0.x, r0.y, r0.x + 2, r0.y + 2 );
            return;
        }
    }

//    if( m_nPoints < 2  )
//        return;

    /* determine color and width */
    wxColour col;

    int width = g_pRouteMan->GetRoutePen()->GetWidth(); //g_route_line_width;
    if( m_width != wxPENSTYLE_INVALID )
        width = m_width;
    if(m_bIsTrack)
        width = g_pRouteMan->GetTrackPen()->GetWidth();

    if( m_bRtIsActive )
    {
        col = g_pRouteMan->GetActiveRoutePen()->GetColour();
    } else if( m_bRtIsSelected ) {
        col = g_pRouteMan->GetSelectedRoutePen()->GetColour();
    } else {
        if( m_Colour == wxEmptyString ) {
            col = g_pRouteMan->GetRoutePen()->GetColour();

            //  For tracks, establish colour based on first icon name
            if(m_bIsTrack) {
                wxRoutePointListNode *node = pRoutePointList->GetFirst();
                RoutePoint *prp = node->GetData();

                if( prp->GetIconName().StartsWith( _T("xmred") ) )
                    col = GetGlobalColor( _T ( "URED" ) );
                else if( prp->GetIconName().StartsWith( _T("xmblue") ) )
                    col = GetGlobalColor( _T ( "BLUE3" ) );
                else if( prp->GetIconName().StartsWith( _T("xmgreen") ) )
                    col = GetGlobalColor( _T ( "UGREN" ) );
                else
                    col = GetGlobalColor( _T ( "CHMGD" ) );
            }
        } else {
            for( unsigned int i = 0; i < sizeof( ::GpxxColorNames ) / sizeof(wxString); i++ ) {
                if( m_Colour == ::GpxxColorNames[i] ) {
                    col = ::GpxxColors[i];
                    break;
                }
            }
        }
    }

    int style = wxSOLID;
    if( m_style != wxPENSTYLE_INVALID ) style = m_style;
    dc.SetPen( *wxThePenList->FindOrCreatePen( col, width, style ) );

    glColor3ub(col.Red(), col.Green(), col.Blue());
    glLineWidth( wxMax( g_GLMinSymbolLineWidth, width ) );

    dc.SetGLStipple();
    glBegin(GL_LINE_STRIP);
    float lastlon = 0;
    float lastlat = 0;
    unsigned short int FromSegNo = 1;
    for(wxRoutePointListNode *node = pRoutePointList->GetFirst();
            node; node = node->GetNext()) {
        RoutePoint *prp = node->GetData();
        unsigned short int ToSegNo = prp->m_GPXTrkSegNo;

        /* crosses IDL? if so break up into two segments */
        int dir = 0;
        if(prp->m_lon > 150 && lastlon < -150)
            dir = -1;
        else if(prp->m_lon < -150 && lastlon > 150)
            dir = 1;

        wxPoint r;
        if (FromSegNo != ToSegNo)
        {
            glEnd();
            FromSegNo = ToSegNo;
            glBegin(GL_LINE_STRIP);
        }
        if(dir)
        {
            double crosslat = lat_rl_crosses_meridian(lastlat, lastlon, prp->m_lat, prp->m_lon, 180.0);
            if(cc1->GetCanvasPointPix( crosslat, dir*180, &r))
                glVertex2i(r.x, r.y);
            glEnd();
            glBegin(GL_LINE_STRIP);
            if(cc1->GetCanvasPointPix( crosslat, -dir*180, &r))
                glVertex2i(r.x, r.y);
        }
        lastlat=prp->m_lat;
        lastlon=prp->m_lon;

        if(cc1->GetCanvasPointPix( prp->m_lat, prp->m_lon, &r))
            glVertex2i(r.x, r.y);
        else {
            glEnd();
            glBegin(GL_LINE_STRIP);
        }
    }
    glEnd();
    glDisable (GL_LINE_STIPPLE);

    /* direction arrows.. could probably be further optimized for opengl */
    if( !m_bIsTrack ) {
        wxRoutePointListNode *node = pRoutePointList->GetFirst();
        wxPoint rpt1, rpt2;
        while(node) {
            RoutePoint *prp = node->GetData();
            cc1->GetCanvasPointPix( prp->m_lat, prp->m_lon, &rpt2 );
            if(node != pRoutePointList->GetFirst())
                RenderSegmentArrowsGL( rpt1.x, rpt1.y, rpt2.x, rpt2.y, cc1->GetVP() );
            rpt1 = rpt2;
            node = node->GetNext();
        }
    }

    /*  Route points  */
    for(wxRoutePointListNode *node = pRoutePointList->GetFirst(); node; node = node->GetNext()) {
        RoutePoint *prp = node->GetData();
        if ( !m_bVisible && prp->m_bKeepXRoute )
            prp->DrawGL( VP );
        else if (m_bVisible)
            prp->DrawGL( VP );

    }

#endif
}
Beispiel #9
0
/* CTextureCanvas::drawTexture
 * Draws the currently opened composite texture
 *******************************************************************/
void CTextureCanvas::drawTexture()
{
	// Push matrix
	glPushMatrix();

	// Translate to middle of the canvas
	glTranslated(GetSize().x * 0.5, GetSize().y * 0.5, 0);

	// Zoom
	double yscale = (tx_arc ? scale * 1.2 : scale);
	glScaled(scale, yscale, 1);

	// Draw offset guides if needed
	drawOffsetLines();

	// Apply texture scale
	double tscalex = 1;
	double tscaley = 1;
	if (tex_scale)
	{
		tscalex = texture->getScaleX();
		if (tscalex == 0) tscalex = 1;
		tscaley = texture->getScaleY();
		if (tscaley == 0) tscaley = 1;
		glScaled(1.0 / tscalex, 1.0 / tscaley, 1);
	}

	// Calculate top-left position of texture (for glScissor, since it ignores the current translation/scale)
	point2_t screen_tl = texToScreenPosition(0, 0);
	int left = screen_tl.x;
	int top = screen_tl.y;

	// Translate by offsets if needed
	if (view_type == 0) // No offsets
		glTranslated(texture->getWidth() * -0.5, texture->getHeight() * -0.5, 0);
	if (view_type >= 1) // Sprite offsets
		glTranslated(-texture->getOffsetX(), -texture->getOffsetY(), 0);
	if (view_type == 2) // HUD offsets
		glTranslated(-160 * tscalex, -100 * tscaley, 0);

	// Draw the texture border
	drawTextureBorder();

	// Enable textures
	glEnable(GL_TEXTURE_2D);

	// First, draw patches semitransparently (for anything outside the texture)
	// But only if we are drawing stuff outside the texture area
	if (draw_outside)
	{
		for (uint32_t a = 0; a < texture->nPatches(); a++)
			drawPatch(a, true);
	}

	// Reset colouring
	OpenGL::setColour(COL_WHITE);

	// If we're currently dragging, draw a 'basic' preview of the texture using opengl
	if (dragging)
	{
		glEnable(GL_SCISSOR_TEST);
		glScissor(left, top, texture->getWidth() * scale * (1.0 / tscalex), texture->getHeight() * yscale * (1.0 / tscaley));
		for (uint32_t a = 0; a < texture->nPatches(); a++)
			drawPatch(a);
		glDisable(GL_SCISSOR_TEST);
	}

	// Otherwise, draw the fully generated texture
	else
	{
		// Generate if needed
		if (!tex_preview.isLoaded())
		{
			// Determine image type
			SIType type = PALMASK;
			if (blend_rgba) type = RGBA;

			// CTexture -> temp Image -> GLTexture
			SImage temp(type);
			texture->toImage(temp, parent, &palette, blend_rgba);
			tex_preview.loadImage(&temp, &palette);
		}

		// Draw it
		tex_preview.draw2d();
	}

	// Disable textures
	glDisable(GL_TEXTURE_2D);

	// Now loop through selected patches and draw selection outlines
	OpenGL::setColour(70, 210, 220, 255, BLEND_NORMAL);
	glEnable(GL_LINE_SMOOTH);
	glLineWidth(1.5f);
	for (size_t a = 0; a < selected_patches.size(); a++)
	{
		// Skip if not selected
		if (!selected_patches[a])
			continue;

		// Get patch
		CTPatch* patch = texture->getPatch(a);
		CTPatchEx* epatch = (CTPatchEx*)patch;

		// Check for rotation
		if (texture->isExtended() && (epatch->getRotation() == 90 || epatch->getRotation() == -90))
		{
			// Draw outline, width/height swapped
			glBegin(GL_LINE_LOOP);
			glVertex2i(patch->xOffset(), patch->yOffset());
			glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_textures[a]->getWidth());
			glVertex2i(patch->xOffset() + (int)patch_textures[a]->getHeight(), patch->yOffset() + (int)patch_textures[a]->getWidth());
			glVertex2i(patch->xOffset() + (int)patch_textures[a]->getHeight(), patch->yOffset());
			glEnd();
		}
		else
		{
			// Draw outline
			glBegin(GL_LINE_LOOP);
			glVertex2i(patch->xOffset(), patch->yOffset());
			glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_textures[a]->getHeight());
			glVertex2i(patch->xOffset() + (int)patch_textures[a]->getWidth(), patch->yOffset() + (int)patch_textures[a]->getHeight());
			glVertex2i(patch->xOffset() + (int)patch_textures[a]->getWidth(), patch->yOffset());
			glEnd();
		}
	}

	// Finally, draw a hilight outline if anything is hilighted
	if (hilight_patch >= 0 && hilight_patch < (int)texture->nPatches())
	{
		// Set colour
		OpenGL::setColour(255, 255, 255, 150, BLEND_ADDITIVE);

		// Get patch
		CTPatch* patch = texture->getPatch(hilight_patch);
		CTPatchEx* epatch = (CTPatchEx*)patch;
		GLTexture* patch_texture = patch_textures[hilight_patch];

		// Check for rotation
		if (texture->isExtended() && (epatch->getRotation() == 90 || epatch->getRotation() == -90))
		{
			// Draw outline, width/height swapped
			glBegin(GL_LINE_LOOP);
			glVertex2i(patch->xOffset(), patch->yOffset());
			glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_texture->getWidth());
			glVertex2i(patch->xOffset() + (int)patch_texture->getHeight(), patch->yOffset() + (int)patch_texture->getWidth());
			glVertex2i(patch->xOffset() + (int)patch_texture->getHeight(), patch->yOffset());
			glEnd();
		}
		else
		{
			// Draw outline
			glBegin(GL_LINE_LOOP);
			glVertex2i(patch->xOffset(), patch->yOffset());
			glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_texture->getHeight());
			glVertex2i(patch->xOffset() + (int)patch_texture->getWidth(), patch->yOffset() + (int)patch_texture->getHeight());
			glVertex2i(patch->xOffset() + (int)patch_texture->getWidth(), patch->yOffset());
			glEnd();
		}
	}
	glDisable(GL_LINE_SMOOTH);
	glLineWidth(1.0f);

	// Pop matrix
	glPopMatrix();
}
Beispiel #10
0
/* CTextureCanvas::drawTextureBorder
 * Draws a black border around the texture
 *******************************************************************/
void CTextureCanvas::drawTextureBorder()
{
	// Draw the texture border
	double ext = 0.11;
	glLineWidth(2.0f);
	OpenGL::setColour(COL_BLACK);
	glBegin(GL_LINE_LOOP);
	glVertex2d(-ext, -ext);
	glVertex2d(-ext, texture->getHeight()+ext);
	glVertex2d(texture->getWidth()+ext, texture->getHeight()+ext);
	glVertex2d(texture->getWidth()+ext, -ext);
	glEnd();
	glLineWidth(1.0f);

	// Draw vertical ticks
	int y = 0;
	glColor4f(0.0f, 0.0f, 0.0f, 0.6f);
	while (y <= texture->getHeight())
	{
		glBegin(GL_LINES);
		glVertex2i(-4, y);
		glVertex2i(0, y);
		glVertex2i(texture->getWidth(), y);
		glVertex2i(texture->getWidth() + 4, y);
		glEnd();

		y += 8;
	}

	// Draw horizontal ticks
	int x = 0;
	while (x <= texture->getWidth())
	{
		glBegin(GL_LINES);
		glVertex2i(x, -4);
		glVertex2i(x, 0);
		glVertex2i(x, texture->getHeight());
		glVertex2i(x, texture->getHeight() + 4);
		glEnd();

		x += 8;
	}

	// Draw grid
	if (show_grid)
	{
		// Draw inverted grid lines
		glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
		glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

		// Vertical
		y = 8;
		while (y <= texture->getHeight() - 8)
		{
			glBegin(GL_LINES);
			glVertex2i(0, y);
			glVertex2i(texture->getWidth(), y);
			glEnd();

			y += 8;
		}

		// Horizontal
		x = 8;
		while (x <= texture->getWidth() - 8)
		{
			glBegin(GL_LINES);
			glVertex2i(x, 0);
			glVertex2i(x, texture->getHeight());
			glEnd();

			x += 8;
		}


		// Darken grid lines
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glColor4f(0.0f, 0.0f, 0.0f, 0.5f);

		// Vertical
		y = 8;
		while (y <= texture->getHeight() - 8)
		{
			glBegin(GL_LINES);
			glVertex2i(0, y);
			glVertex2i(texture->getWidth(), y);
			glEnd();

			y += 8;
		}

		// Horizontal
		x = 8;
		while (x <= texture->getWidth() - 8)
		{
			glBegin(GL_LINES);
			glVertex2i(x, 0);
			glVertex2i(x, texture->getHeight());
			glEnd();

			x += 8;
		}
	}
}
Beispiel #11
0
void cc2DLabel::drawMeOnly2D(CC_DRAW_CONTEXT& context)
{
	if (!m_dispIn2D)
		return;

	assert(!m_points.empty());

	//standard case: list names pushing
	bool pushName = MACRO_DrawEntityNames(context);
	if (pushName)
		glPushName(getUniqueID());

	//we should already be in orthoprojective & centered omde
	//glOrtho(-halfW,halfW,-halfH,halfH,-maxS,maxS);

	int strHeight = 0;
	int titleHeight = 0;
	QString title(getName());
	QStringList body;
	GLdouble arrowDestX=-1.0,arrowDestY=-1.0;
	QFont bodyFont,titleFont;
	if (!pushName)
	{
		/*** line from 2D point to label ***/

		//compute arrow head position
		CCVector3 arrowDest;
		m_points[0].cloud->getPoint(m_points[0].index,arrowDest);
		for (unsigned i=1;i<m_points.size();++i)
			arrowDest += *m_points[i].cloud->getPointPersistentPtr(m_points[i].index);
		arrowDest /= (PointCoordinateType)m_points.size();

		//project it in 2D screen coordinates
		int VP[4];
		context._win->getViewportArray(VP);
		const double* MM = context._win->getModelViewMatd(); //viewMat
		const double* MP = context._win->getProjectionMatd(); //projMat
		GLdouble zp;
		gluProject(arrowDest.x,arrowDest.y,arrowDest.z,MM,MP,VP,&arrowDestX,&arrowDestY,&zp);

		/*** label border ***/
		bodyFont = context._win->getTextDisplayFont(); //takes rendering zoom into account!
		titleFont = QFont(context._win->getTextDisplayFont()); //takes rendering zoom into account!
		titleFont.setBold(true);
		QFontMetrics titleFontMetrics(titleFont);
		QFontMetrics bodyFontMetrics(bodyFont);

		strHeight = bodyFontMetrics.height();
		titleHeight = titleFontMetrics.height();

		if (m_showFullBody)
			body = getLabelContent(context.dispNumberPrecision);

		//base box dimension
		int dx = 150;
		dx = std::max(dx,titleFontMetrics.width(title));

		int dy = c_margin;	//top vertical margin
		dy += titleHeight;	//title
		if (!body.empty())
		{
			dy += c_margin;	//vertical margin above separator
			for (int j=0; j<body.size(); ++j)
			{
				dx = std::max(dx,bodyFontMetrics.width(body[j]));
				dy += strHeight; //body line height
			}
			dy += c_margin;	//vertical margin below text
		}
		else
		{
			dy += c_margin;	// vertical margin (purely for aesthetics)
		}
		dy += c_margin;		// bottom vertical margin
		dx += c_margin*2;	// horizontal margins

		//main rectangle
		m_labelROI[0]=0;
		m_labelROI[1]=0;
		m_labelROI[2]=dx;
		m_labelROI[3]=dy;

		//close button
		/*m_closeButtonROI[2]=dx-c_margin;
		m_closeButtonROI[0]=m_closeButtonROI[2]-c_buttonSize;
		m_closeButtonROI[3]=c_margin;
		m_closeButtonROI[1]=m_closeButtonROI[3]+c_buttonSize;
		//*/

		//automatically elide the title
		//title = titleFontMetrics.elidedText(title,Qt::ElideRight,m_closeButtonROI[0]-2*c_margin);
	}

	int halfW = (context.glW>>1);
	int halfH = (context.glH>>1);

	//draw label rectangle
	int xStart = m_lastScreenPos[0] = (int)((float)context.glW * m_screenPos[0]);
	int yStart = m_lastScreenPos[1] = (int)((float)context.glH * (1.0f-m_screenPos[1]));

	//colors
	bool highlighted = (!pushName && isSelected());
	//default background color
	colorType defaultBkgColor[4];
	memcpy(defaultBkgColor,context.labelDefaultCol,sizeof(colorType)*3);
	defaultBkgColor[3] = (colorType)((float)context.labelsTransparency*(float)MAX_COLOR_COMP/100.0f);
	//default border color (mustn't be totally transparent!)
	colorType defaultBorderColor[4];
	if (highlighted)
		memcpy(defaultBorderColor,ccColor::red,sizeof(colorType)*3);
	else
		memcpy(defaultBorderColor,context.labelDefaultCol,sizeof(colorType)*3);
	defaultBorderColor[3] = (colorType)((float)(50+context.labelsTransparency/2)*(float)MAX_COLOR_COMP/100.0f);

	glPushAttrib(GL_COLOR_BUFFER_BIT);
	glEnable(GL_BLEND);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glTranslatef(static_cast<GLfloat>(-halfW+xStart),static_cast<GLfloat>(-halfH+yStart),0);

	if (!pushName)
	{
		//compute arrow base position relatively to the label rectangle (for 0 to 8)
		int arrowBaseConfig = 0;
		int iArrowDestX = (int)arrowDestX-xStart;
		int iArrowDestY = (int)arrowDestY-yStart;
		{
			if (iArrowDestX < m_labelROI[0]) //left
				arrowBaseConfig += 0;
			else if (iArrowDestX > m_labelROI[2]) //Right
				arrowBaseConfig += 2;
			else  //Middle
				arrowBaseConfig += 1;

			if (iArrowDestY > -m_labelROI[1]) //Top
				arrowBaseConfig += 0;
			else if (iArrowDestY < -m_labelROI[3]) //Bottom
				arrowBaseConfig += 6;
			else  //Middle
				arrowBaseConfig += 3;
		}

		//we make the arrow base start from the nearest corner
		if (arrowBaseConfig != 4) //4 = label above point!
		{
			glColor4ubv(defaultBorderColor);
			glBegin(GL_TRIANGLE_FAN);
			glVertex2d(arrowDestX-xStart,arrowDestY-yStart);
			switch(arrowBaseConfig)
			{
			case 0: //top-left corner
				glVertex2i(m_labelROI[0], -m_labelROI[1]-2*c_arrowBaseSize);
				glVertex2i(m_labelROI[0], -m_labelROI[1]);
				glVertex2i(m_labelROI[0]+2*c_arrowBaseSize, -m_labelROI[1]);
				break;
			case 1: //top-middle edge
				glVertex2i(std::max(m_labelROI[0],iArrowDestX-c_arrowBaseSize), -m_labelROI[1]);
				glVertex2i(std::min(m_labelROI[2],iArrowDestX+c_arrowBaseSize), -m_labelROI[1]);
				break;
			case 2: //top-right corner
				glVertex2i(m_labelROI[2], -m_labelROI[1]-2*c_arrowBaseSize);
				glVertex2i(m_labelROI[2], -m_labelROI[1]);
				glVertex2i(m_labelROI[2]-2*c_arrowBaseSize, -m_labelROI[1]);
				break;
			case 3: //middle-left edge
				glVertex2i(m_labelROI[0], std::min(-m_labelROI[1],iArrowDestY+c_arrowBaseSize));
				glVertex2i(m_labelROI[0], std::max(-m_labelROI[3],iArrowDestY-c_arrowBaseSize));
				break;
			case 4: //middle of rectangle!
				break;
			case 5: //middle-right edge
				glVertex2i(m_labelROI[2], std::min(-m_labelROI[1],iArrowDestY+c_arrowBaseSize));
				glVertex2i(m_labelROI[2], std::max(-m_labelROI[3],iArrowDestY-c_arrowBaseSize));
				break;
			case 6: //bottom-left corner
				glVertex2i(m_labelROI[0], -m_labelROI[3]+2*c_arrowBaseSize);
				glVertex2i(m_labelROI[0], -m_labelROI[3]);
				glVertex2i(m_labelROI[0]+2*c_arrowBaseSize, -m_labelROI[3]);
				break;
			case 7: //bottom-middle edge
				glVertex2i(std::max(m_labelROI[0],iArrowDestX-c_arrowBaseSize), -m_labelROI[3]);
				glVertex2i(std::min(m_labelROI[2],iArrowDestX+c_arrowBaseSize), -m_labelROI[3]);
				break;
			case 8: //bottom-right corner
				glVertex2i(m_labelROI[2], -m_labelROI[3]+2*c_arrowBaseSize);
				glVertex2i(m_labelROI[2], -m_labelROI[3]);
				glVertex2i(m_labelROI[2]-2*c_arrowBaseSize, -m_labelROI[3]);
				break;
			}
			glEnd();
		}
	}

	//main rectangle
	glColor4ubv(defaultBkgColor);
    glBegin(GL_QUADS);
    glVertex2i(m_labelROI[0], -m_labelROI[1]);
    glVertex2i(m_labelROI[0], -m_labelROI[3]);
    glVertex2i(m_labelROI[2], -m_labelROI[3]);
    glVertex2i(m_labelROI[2], -m_labelROI[1]);
    glEnd();

	//if (highlighted)
	{
		glPushAttrib(GL_LINE_BIT);
		glLineWidth(3.0f);
		glColor4ubv(defaultBorderColor);
		glBegin(GL_LINE_LOOP);
		glVertex2i(m_labelROI[0], -m_labelROI[1]);
		glVertex2i(m_labelROI[0], -m_labelROI[3]);
		glVertex2i(m_labelROI[2], -m_labelROI[3]);
		glVertex2i(m_labelROI[2], -m_labelROI[1]);
		glEnd();
		glPopAttrib();
	}

	//draw close button
	/*glColor3ubv(ccColor::black);
    glBegin(GL_LINE_LOOP);
    glVertex2i(m_closeButtonROI[0],-m_closeButtonROI[1]);
    glVertex2i(m_closeButtonROI[0],-m_closeButtonROI[3]);
    glVertex2i(m_closeButtonROI[2],-m_closeButtonROI[3]);
    glVertex2i(m_closeButtonROI[2],-m_closeButtonROI[1]);
    glEnd();
    glBegin(GL_LINES);
    glVertex2i(m_closeButtonROI[0]+2,-m_closeButtonROI[1]+2);
    glVertex2i(m_closeButtonROI[2]-2,-m_closeButtonROI[3]-2);
    glVertex2i(m_closeButtonROI[2]-2,-m_closeButtonROI[1]+2);
    glVertex2i(m_closeButtonROI[0]+2,-m_closeButtonROI[3]-2);
    glEnd();
	//*/

	//display text
	if (!pushName)
	{
		int xStartRel = c_margin;
		int yStartRel = -c_margin;
		yStartRel -= titleHeight;

		const colorType* defaultTextColor = (context.labelsTransparency<40 ? context.textDefaultCol : ccColor::darkBlue);

		context._win->displayText(title,xStart+xStartRel,yStart+yStartRel,ccGenericGLDisplay::ALIGN_DEFAULT,0,defaultTextColor,&titleFont);
		yStartRel -= c_margin;

		if (!body.empty())
		{
			//line separation
			glColor4ubv(defaultBorderColor);
			glBegin(GL_LINES);
			glVertex2i(xStartRel,yStartRel);
			glVertex2i(xStartRel+m_labelROI[2]-m_labelROI[0]-2*c_margin,yStartRel);
			glEnd();

			//display body
			yStartRel -= c_margin;
			for (int i=0; i<body.size(); ++i)
			{
				yStartRel -= strHeight;
				context._win->displayText(body[i],xStart+xStartRel,yStart+yStartRel,ccGenericGLDisplay::ALIGN_DEFAULT,0,defaultTextColor,&bodyFont);
			}
		}
	}

	glPopAttrib();

	glPopMatrix();

	if (pushName)
		glPopName();
}
Beispiel #12
0
	void renderString(int x, int y, string glstring){

		unsigned int i = 0;
		int uc;
		double tx, ty, span = 0;
		//Textures::TEXTURE_RGBA Tex;
		TextureID ftex;

		wchar_t* wstr = nullptr;
		MBToWC(glstring.c_str(), wstr, 128);

		glMatrixMode(GL_PROJECTION);
		glPushMatrix();
		glLoadIdentity();
		glOrtho(0, ww, wh, 0, -1.0, 1.0);
		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glEnable(GL_TEXTURE_2D);
		for (unsigned int k = 0; k < wstrlen(wstr); k++){
			glLoadIdentity();
			glColor4f(r, g, b, a);
			glTranslated(x + 1 + span, y + 1, 0);
			uc = wstr[k];
			if (!useUnicodeASCIIFont && glstring[i]>=0 && glstring[i] <= 127){
				glprint(x + 1 + (int)span, y + 1, string() + glstring[i]);
			}
			else{
				if (!unicodeTexAval[uc / 256]) {
					//printf("[Console][Event]");
					//printf("Loading unicode font texture #%d\n", uc / 256);
					std::stringstream ss;
					ss << "Textures\\Fonts\\unicode\\unicode_glyph_" << uc / 256 << ".bmp";
					ftex = Textures::LoadFontTexture(ss.str());
					unicodeTex[uc / 256] = ftex;
					unicodeTexAval[uc / 256] = true;
				}
				else{
					ftex = unicodeTex[uc / 256];
				}

				tx = ((uc % 256) % 16) / 16.0;
				ty = 1 - ((uc % 256) / 16) / 16.0;
				glBindTexture(GL_TEXTURE_2D, ftex);
				glBegin(GL_QUADS);
				glColor4f(0.5, 0.5, 0.5, a);
				glTexCoord2d(tx, ty);
				glVertex2i(1, 1);
				glTexCoord2d(tx + 0.0625, ty);
				glVertex2i(17, 1);
				glTexCoord2d(tx + 0.0625, ty - 0.0625);
				glVertex2i(17, 17);
				glTexCoord2d(tx, ty - 0.0625);
				glVertex2i(1, 17);
				glColor4f(r, g, b, a);
				glTexCoord2d(tx, ty);
				glVertex2i(0, 0);
				glTexCoord2d(tx + 0.0625, ty);
				glVertex2i(16, 0);
				glTexCoord2d(tx + 0.0625, ty - 0.0625);
				glVertex2i(16, 16);
				glTexCoord2d(tx, ty - 0.0625);
				glVertex2i(0, 16);
				glEnd();
			}
			if (glstring[i] >= 0 && glstring[i] <= 127){
				i += 1;
				span += 10;
			}
			else{
				i += 2;
				span += 16;
			}
		}

		glMatrixMode(GL_PROJECTION);

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

		glColor4f(1.0, 1.0, 1.0, 1.0);
		free(wstr);
	}
Beispiel #13
0
void SpaceShip::draw() {
	Point abc[4];

	// Right & Left Carriers
	glLineWidth(2);
	glColor3f(0.799, 0.1098, 0.0588);

	glBegin(GL_TRIANGLE_STRIP);
	glVertex2i(startX + 10, (startY + 0));
	glVertex2i(startX + 20, (startY + 10));
	glVertex2i(startX + 7, (startY + 23));
	glVertex2i(startX + 17, (startY + 30));
	glEnd();

	glBegin(GL_TRIANGLE_STRIP);
	glVertex2i(startX + 68, (startY + 0));
	glVertex2i(startX + 58, (startY + 10));
	glVertex2i(startX + 72, (startY + 23));
	glVertex2i(startX + 62, (startY + 30));
	glEnd();

	// Main Body
	glLineWidth(4);
	glColor3f(0.925, 0.925, 0.925);

	abc[0].setxy(startX + 22, (startY + 9));
	abc[1].setxy(startX + 14, (startY + 28));
	abc[2].setxy(startX + 16, (startY + 86));
	abc[3].setxy(startX + 39, (startY + 97));
	basicShapes.drawCurve(abc[0], abc[1], abc[2], abc[3]);

	abc[0].setxy(startX + 56, (startY + 9));
	abc[1].setxy(startX + 66, (startY + 28));
	abc[2].setxy(startX + 62, (startY + 86));
	abc[3].setxy(startX + 39, (startY + 97));
	basicShapes.drawCurve(abc[0], abc[1], abc[2], abc[3]);

	abc[0].setxy(startX + 22, (startY + 9));
	abc[1].setxy(startX + 34, (startY + 16));
	abc[2].setxy(startX + 44, (startY + 16));
	abc[3].setxy(startX + 56, (startY + 9));
	basicShapes.drawCurve(abc[0], abc[1], abc[2], abc[3]);

	basicShapes.solidCircle(startX + 39, (startY + 82), 13);
	basicShapes.solidCircle(startX + 39, (startY + 65), 20);
	basicShapes.solidCircle(startX + 39, (startY + 53), 22);
	basicShapes.solidCircle(startX + 39, (startY + 35), 23);
	basicShapes.solidCircle(startX + 27, (startY + 20), 9);
	basicShapes.solidCircle(startX + 52, (startY + 20), 9);

	// Glass Window
	glColor3f(0.827, 0.96, 1);
	basicShapes.solidCircle(startX + 39, (startY + 60), 10);

	// Middle Carrier
	glLineWidth(2.8);
	glColor3f(0.799, 0.1098, 0.0588);

	glBegin(GL_LINES);
	glVertex2i(startX + 39, (startY + 0));
	glVertex2i(startX + 39, (startY + 30));
	glEnd();

	// Glass Frame
	glLineWidth(2);
	basicShapes.hallowCircle(startX + 39, (startY + 60), 10);

}
Beispiel #14
0
void    GLUI_EditText::draw( int x, int y )
{
  int orig;
  int name_x;

  if ( NOT can_draw() )
    return;

  orig = set_to_glut_window();

  name_x = MAX(text_x_offset - string_width(this->name) - 3,0);
  draw_name( name_x , 13);

  glBegin( GL_LINES );
  glColor3f( .5, .5, .5 );
  glVertex2i( text_x_offset, 0 );     glVertex2i( w, 0 );
  glVertex2i( text_x_offset, 0 );     glVertex2i( text_x_offset, h );     

  glColor3f( 1., 1., 1. );
  glVertex2i( text_x_offset, h );     glVertex2i( w, h );
  glVertex2i( w, h );                 glVertex2i( w, 0 );

  if ( enabled )
    glColor3f( 0., 0., 0. );
  else
    glColor3f( .25, .25, .25 );
  glVertex2i( text_x_offset+1, 1 );     glVertex2i( w-1, 1 );
  glVertex2i( text_x_offset+1, 1 );     glVertex2i( text_x_offset+1, h-1 );

  glColor3f( .75, .75, .75 );
  glVertex2i( text_x_offset+1, h-1 );     glVertex2i( w-1, h-1 );
  glVertex2i( w-1, h-1 );                 glVertex2i( w-1, 1 );
  glEnd();

  /** Find where to draw the text **/
  update_substring_bounds();
  draw_text(0,0);
  
  draw_insertion_pt();

  restore_window(orig);
}
Beispiel #15
0
bool cScene::LoadLevel(int level)
{
	bool res;
	FILE *fd;
	char file[16];
	int i,j,px,py;
	int tile;
	float coordx_tile, coordy_tile;

	res=true;

	if(level<10) sprintf(file,"%s0%d%s",(char *)FILENAME,level,(char *)FILENAME_EXT);
	else		 sprintf(file,"%s%d%s",(char *)FILENAME,level,(char *)FILENAME_EXT);

	fd=fopen(file,"r");
	if(fd==NULL) return false;

	int width = (level == 1) ? SCENE_WIDTH : SCENE_WIDTH_2;

	id_DL=glGenLists(1);
	glNewList(id_DL,GL_COMPILE);
		glBegin(GL_QUADS);
	
			for(j=SCENE_HEIGHT-1;j>=0;j--)
			{
				px=SCENE_Xo;
				py=SCENE_Yo+(j*TILE_SIZE);

				for(i=0;i<width;i++)
				{
					fscanf(fd,"%d",&tile);
					if (tile == 0)
					{
						if (level == 1) map[(j*width)+i]=0;
						else map2[(j*width) + i] = 0;
					}
					else
					{
						//PODRIAMOS COMPROBAR ALGUNA TILE EN CONCRETO SI QUEREMOS QUE CIERTOS ID TENGAN ANIMACION
						//TODO
						//Tiles = 1,2,3,...
						float divY = (level == 1) ? 0.25f : 0.125f;
						if (level == 1) map[(j*width)+i] = tile;
						else map2[(j*width) + i] = tile;
						coordy_tile = (tile - 1) / tilesFila * divY;
						
						coordx_tile = ((tile-1) % (tilesFila)) * (float)(1.0f / (float)tilesFila);

						glTexCoord2f(coordx_tile       ,coordy_tile+ divY);	glVertex2i(px           ,py           );
						glTexCoord2f(coordx_tile+ (1.0f/(float)tilesFila),coordy_tile+ divY);	glVertex2i(px+BLOCK_SIZE,py           );
						glTexCoord2f(coordx_tile+ (1.0f / (float)tilesFila),coordy_tile       );	glVertex2i(px+BLOCK_SIZE,py+BLOCK_SIZE);
						glTexCoord2f(coordx_tile       ,coordy_tile       );	glVertex2i(px           ,py+BLOCK_SIZE);
					}
					px+=TILE_SIZE;
				}
			}

		glEnd();
	glEndList();

	fclose(fd);

	return res;
}
Beispiel #16
0
void    GLUI_EditText::draw_text( int x, int y )
{
  int text_x, i, sel_lo, sel_hi;
  int orig;

  if ( NOT can_draw() )
    return;

  if ( debug )    dump( stdout, "-> DRAW_TEXT" );

  orig = set_to_glut_window();

  if ( NOT draw_text_only ) {
    if ( enabled )
      glColor3f( 1., 1., 1. );
    else
      set_to_bkgd_color();
    glDisable( GL_CULL_FACE );
    glBegin( GL_QUADS );
    glVertex2i( text_x_offset+2, 2 );     glVertex2i( w-2, 2 );
    glVertex2i( w-2, h-2 );               glVertex2i( text_x_offset+2, h-2 );
    glEnd();
  }

  /** Find where to draw the text **/

  text_x = text_x_offset + 2 + GLUI_EDITTEXT_BOXINNERMARGINX;

  /*printf( "text_x: %d      substr_width: %d     start/end: %d/%d\n",
    text_x,     substring_width( substring_start, substring_end ),
    substring_start, substring_end );
    */
  /** Find lower and upper selection bounds **/
  sel_lo = MIN(sel_start, sel_end );
  sel_hi = MAX(sel_start, sel_end );

  int sel_x_start, sel_x_end, delta;

  /** Draw selection area dark **/
  if ( sel_start != sel_end ) {
    sel_x_start = text_x;
    sel_x_end   = text_x;
    for( i=substring_start; i<=substring_end; i++ ) {
      delta = char_width( text[i] );

      if ( i < sel_lo ) {
	sel_x_start += delta;
	sel_x_end   += delta;
      }
      else if ( i < sel_hi ) {
	sel_x_end   += delta;
      }
    }

    glColor3f( 0.0f, 0.0f, .6f );
    glBegin( GL_QUADS );
    glVertex2i( sel_x_start, 2 );    glVertex2i( sel_x_end, 2 );
    glVertex2i( sel_x_end, h-2 );    glVertex2i( sel_x_start, h-2 );
    glEnd();
  }
   

  if ( sel_start == sel_end ) {   /* No current selection */
    if ( enabled )
      glColor3b( 0, 0, 0 );
    else
      glColor3b( 32, 32, 32 );
      
    glRasterPos2i( text_x, 13);
    for( i=substring_start; i<=substring_end; i++ ) {
      glutBitmapCharacter( get_font(), this->text[i] );
    }
  }
  else {                          /* There is a selection */
    int x = text_x;
    for( i=substring_start; i<=substring_end; i++ ) {
      if ( IN_BOUNDS( i, sel_lo, sel_hi-1)) { /* This character is selected */
	glColor3f( 1., 1., 1. );
	glRasterPos2i( x, 13);
	glutBitmapCharacter( get_font(), this->text[i] );
      }
      else {
	glColor3f( 0., 0., 0. );
	glRasterPos2i( x, 13);
	glutBitmapCharacter( get_font(), this->text[i] );
      }
      
      x += char_width( text[i] );
    }
  }

  restore_window( orig );

  if ( debug )    dump( stdout, "<- DRAW_TEXT" );  
}
Beispiel #17
0
void buttonList::buttonDraw(){
	int fontx;
	int fonty;
	current = start;
	while(current != NULL){
		if(current->display){
			if (current->highlighted) {
				glColor3f(0.0f,0.0f,0.0f);
			}
			else {
				glColor3f(0.0f,0.0f,0.0f);
			}

			glBegin(GL_QUADS);
				glVertex2i( current->x,							current->y						);
				glVertex2i( current->x,							current->y+current->h );
				glVertex2i( current->x+current->w,	current->y+current->h );
				glVertex2i( current->x+current->w, 	current->y						);
			glEnd();

			glLineWidth(3);

			if (current->pressed) {
				glColor3f(0.0f,0.0f,0.0f);
			}
			else {
				glColor3f(0.0f,0.0f,0.0f);
			}

			glBegin(GL_LINE_STRIP);
				glVertex2i( current->x+current->w, current->y      );
				glVertex2i( current->x     , current->y      );
				glVertex2i( current->x     , current->y+current->h );
			glEnd();

			if (current->pressed) {
				glColor3f(0.0f,0.0f,0.0f);
			}
			else {
				glColor3f(0.0f,0.0f,0.0f);
			}

			glBegin(GL_LINE_STRIP);
				glVertex2i( current->x,							current->y+current->h );
				glVertex2i( current->x+current->w,	current->y+current->h );
				glVertex2i( current->x+current->w,	current->y      			);
			glEnd();

			glLineWidth(1);
			const unsigned char* tempLabel = (const unsigned char*) current->label;
			fontx = current->x + (current->w - glutBitmapLength(GLUT_BITMAP_HELVETICA_10,tempLabel)) / 2 ;
			fonty = current->y + (current->h+10)/2;

			if (current->pressed) {
				fontx+=2;
				fonty+=2;
			}

			if(current->highlighted)
			{
				glColor3f(0,0,0);
				displayText(GLUT_BITMAP_HELVETICA_10,current->label,fontx,fonty);
				fontx--;
				fonty--;
			}

			glColor3f(0,0,0);
			displayText(GLUT_BITMAP_HELVETICA_10,current->label,fontx,fonty);
		}

		current = current->next;
	}
}