Пример #1
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);
	
}
Пример #2
0
static void
gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
  GLint teeth, GLfloat tooth_depth)
{
  GLint i;
  GLfloat r0, r1, r2;
  GLfloat angle, da;
  GLfloat u, v, len;

  r0 = inner_radius;
  r1 = outer_radius - tooth_depth / 2.0;
  r2 = outer_radius + tooth_depth / 2.0;

  da = 2.0 * M_PI / teeth / 4.0;

  glShadeModel(GL_FLAT);

  glNormal3f(0.0, 0.0, 1.0);

  /* draw front face */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i <= teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    if (i < teeth) {
      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
    }
  }
  glEnd();

  /* draw front sides of teeth */
  glBegin(GL_QUADS);
  da = 2.0 * M_PI / teeth / 4.0;
  for (i = 0; i < teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;

    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
  }
  glEnd();

  glNormal3f(0.0, 0.0, -1.0);

  /* draw back face */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i <= teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    if (i < teeth) {
      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    }
  }
  glEnd();

  /* draw back sides of teeth */
  glBegin(GL_QUADS);
  da = 2.0 * M_PI / teeth / 4.0;
  for (i = 0; i < teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;

    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
  }
  glEnd();

  /* draw outward faces of teeth */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i < teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;

    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
    u = r2 * cos(angle + da) - r1 * cos(angle);
    v = r2 * sin(angle + da) - r1 * sin(angle);
    len = sqrt(u * u + v * v);
    u /= len;
    v /= len;
    glNormal3f(v, -u, 0.0);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
    glNormal3f(cos(angle), sin(angle), 0.0);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
    u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
    v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
    glNormal3f(v, -u, 0.0);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glNormal3f(cos(angle), sin(angle), 0.0);
  }

  glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
  glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);

  glEnd();

  glShadeModel(GL_SMOOTH);

  /* draw inside radius cylinder */
  glBegin(GL_QUAD_STRIP);
  for (i = 0; i <= teeth; i++) {
    angle = i * 2.0 * M_PI / teeth;
    glNormal3f(-cos(angle), -sin(angle), 0.0);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
  }
  glEnd();

}
Пример #3
0
void swissArmyLocator::draw(M3dView &view, const MDagPath &/*path*/, 
							M3dView::DisplayStyle style,
							M3dView::DisplayStatus status)
{ 
	// Get the size
	//
	MObject thisNode = thisMObject();

	MPlug plug(thisNode, aSize);
	MDistance sizeVal;
	plug.getValue(sizeVal);

	MPlug arrow1AnglePlug(thisNode, aArrow1Angle);
	MAngle arrow1Angle;
	arrow1AnglePlug.getValue(arrow1Angle);
	double angle1 = -arrow1Angle.asRadians() - 3.1415927/2.0;

	MPlug arrow3AnglePlug(thisNode, aArrow3Angle);
	MAngle arrow3Angle;
	arrow3AnglePlug.getValue(arrow3Angle);
	double angle3 = arrow3Angle.asRadians();

	MPlug statePlug(thisNode, aState);
	int state;
	statePlug.getValue(state);

	MPlug togglePlug(thisNode, aToggle);
	bool toggle;
	togglePlug.getValue(toggle);

	MPlug directionXPlug(thisNode, aArrow2DirectionX);
	MPlug directionYPlug(thisNode, aArrow2DirectionY);
	MPlug directionZPlug(thisNode, aArrow2DirectionZ);
	double dirX;
	double dirY;
	double dirZ;
	directionXPlug.getValue(dirX);
	directionYPlug.getValue(dirY);
	directionZPlug.getValue(dirZ);
	double angle2 = atan2(dirZ,dirX);
	angle2 += 3.1415927;

	float multiplier = (float) sizeVal.asCentimeters();

	view.beginGL(); 

	if ((style == M3dView::kFlatShaded) || 
		(style == M3dView::kGouraudShaded)) 
	{  
		// Push the color settings
		// 
		glPushAttrib(GL_CURRENT_BIT);

		if (status == M3dView::kActive) {
			view.setDrawColor(13, M3dView::kActiveColors);
		} else {
			view.setDrawColor(13, M3dView::kDormantColors);
		}  

		int i;
		int last;

		if (toggle) {
		if (status == M3dView::kActive)
			view.setDrawColor(15, M3dView::kActiveColors);
		else
			view.setDrawColor(15, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = centreCount - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f(centre[i][0] * multiplier,
						   centre[i][1] * multiplier,
						   centre[i][2] * multiplier);
			}
		glEnd();
		}

		if (state == 0) {
		if (status == M3dView::kActive)
			view.setDrawColor(19, M3dView::kActiveColors);
		else
			view.setDrawColor(19, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = state1Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f(state1[i][0] * multiplier,
						   state1[i][1] * multiplier,
						   state1[i][2] * multiplier);
			}
		glEnd();
		}

		if (state == 1) {
		if (status == M3dView::kActive)
			view.setDrawColor(21, M3dView::kActiveColors);
		else
			view.setDrawColor(21, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = state2Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f(state2[i][0] * multiplier,
						   state2[i][1] * multiplier,
						   state2[i][2] * multiplier);
			}
		glEnd();
		}

		if (state == 2) {
		if (status == M3dView::kActive)
			view.setDrawColor(18, M3dView::kActiveColors);
		else
			view.setDrawColor(18, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = state3Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f(state3[i][0] * multiplier,
						   state3[i][1] * multiplier,
						   state3[i][2] * multiplier);
			}
		glEnd();
		}

		if (state == 3) {
		if (status == M3dView::kActive)
			view.setDrawColor(17, M3dView::kActiveColors);
		else
			view.setDrawColor(17, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = state4Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f(state4[i][0] * multiplier,
						   state4[i][1] * multiplier,
						   state4[i][2] * multiplier);
			}
		glEnd();
		}

		if (status == M3dView::kActive)
			view.setDrawColor(12, M3dView::kActiveColors);
		else
			view.setDrawColor(12, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = arrow1Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f( (float) (- arrow1[i][0] * multiplier * cos(angle1) 
						   - arrow1[i][2] * multiplier * sin(angle1)),
						   (float) (arrow1[i][1] * multiplier + delta1),
						   (float) (arrow1[i][2] * multiplier * cos(angle1) -
						   arrow1[i][0] * multiplier * sin(angle1)));
			}
		glEnd();

		if (status == M3dView::kActive)
			view.setDrawColor(16, M3dView::kActiveColors);
		else
			view.setDrawColor(16, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = arrow2Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f( (float) (- arrow2[i][0] * multiplier * cos(angle2) 
						   - arrow2[i][2] * multiplier * sin(angle2)),
						   (float) (arrow2[i][1] * multiplier + delta2),
						   (float) (arrow2[i][2] * multiplier * cos(angle2) -
						   arrow2[i][0] * multiplier * sin(angle2)));
			}
		glEnd();

		if (status == M3dView::kActive)
			view.setDrawColor(13, M3dView::kActiveColors);
		else
			view.setDrawColor(13, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = arrow3Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f( (float) (- arrow3[i][0] * multiplier * cos(angle3) 
						   - arrow3[i][2] * multiplier * sin(angle3)),
						   (float) (arrow3[i][1] * multiplier + delta3),
						   (float) (arrow3[i][2] * multiplier * cos(angle3) -
						   arrow3[i][0] * multiplier * sin(angle3)));
			}
		glEnd();

		if (status == M3dView::kActive)
			view.setDrawColor(5, M3dView::kActiveColors);
		else
			view.setDrawColor(5, M3dView::kDormantColors);
		glBegin(GL_TRIANGLE_FAN);
			last = arrow4Count - 1;
			for (i = 0; i < last; ++i) {
				glVertex3f((float) (arrow4[i][0] * multiplier),
						   (float) (arrow4[i][1] * multiplier + delta4),
						   (float) (arrow4[i][2] * multiplier));
			}
		glEnd();

		glPopAttrib();
	}

	// Draw the outline of the locator
	//
	glBegin(GL_LINES);
	    int i;
		int last;

		if (toggle) {
		last = centreCount - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f(centre[i][0] * multiplier, 
					   centre[i][1] * multiplier, 
					   centre[i][2] * multiplier);
			glVertex3f(centre[i+1][0] * multiplier, 
					   centre[i+1][1] * multiplier, 
					   centre[i+1][2] * multiplier);
		}
		}

		if (state == 0) {
		last = state1Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f(state1[i][0] * multiplier, 
					   state1[i][1] * multiplier, 
					   state1[i][2] * multiplier);
			glVertex3f(state1[i+1][0] * multiplier, 
					   state1[i+1][1] * multiplier, 
					   state1[i+1][2] * multiplier);
		}
		}

		if (state == 1) {
		last = state2Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f(state2[i][0] * multiplier, 
					   state2[i][1] * multiplier, 
					   state2[i][2] * multiplier);
			glVertex3f(state2[i+1][0] * multiplier, 
					   state2[i+1][1] * multiplier, 
					   state2[i+1][2] * multiplier);
		}
		}

		if (state == 2) {
		last = state3Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f(state3[i][0] * multiplier, 
					   state3[i][1] * multiplier, 
					   state3[i][2] * multiplier);
			glVertex3f(state3[i+1][0] * multiplier, 
					   state3[i+1][1] * multiplier, 
					   state3[i+1][2] * multiplier);
		}
		}

		if (state == 3) {
		last = state4Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f(state4[i][0] * multiplier, 
					   state4[i][1] * multiplier, 
					   state4[i][2] * multiplier);
			glVertex3f(state4[i+1][0] * multiplier, 
					   state4[i+1][1] * multiplier, 
					   state4[i+1][2] * multiplier);
		}
		}

		last = arrow1Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f((float) (- arrow1[i][0] * multiplier * cos(angle1) 
					   - arrow1[i][2] * multiplier * sin(angle1)),
					   (float) (arrow1[i][1] * multiplier + delta1),
					   (float) (arrow1[i][2] * multiplier * cos(angle1) -
					   arrow1[i][0] * multiplier * sin(angle1)));
			glVertex3f((float) (- arrow1[i+1][0] * multiplier * cos(angle1) 
					   - arrow1[i+1][2] * multiplier * sin(angle1)),
					   (float) (arrow1[i+1][1] * multiplier + delta1),
					   (float) (arrow1[i+1][2] * multiplier * cos(angle1) -
					   arrow1[i+1][0] * multiplier * sin(angle1)));
		}

		last = arrow2Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f((float) (- arrow2[i][0] * multiplier * cos(angle2) 
					   - arrow2[i][2] * multiplier * sin(angle2)),
					   (float) (arrow2[i][1] * multiplier + delta2),
					   (float) (arrow2[i][2] * multiplier * cos(angle2) -
					   arrow2[i][0] * multiplier * sin(angle2)));
			glVertex3f((float) (- arrow2[i+1][0] * multiplier * cos(angle2) 
					   - arrow2[i+1][2] * multiplier * sin(angle2)),
					   (float) (arrow2[i+1][1] * multiplier + delta2),
					   (float) (arrow2[i+1][2] * multiplier * cos(angle2) -
					   arrow2[i+1][0] * multiplier * sin(angle2)));
		}

		last = arrow3Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f((float) (- arrow3[i][0] * multiplier * cos(angle3) 
					   - arrow3[i][2] * multiplier * sin(angle3)),
					   (float) (arrow3[i][1] * multiplier + delta3),
					   (float) (arrow3[i][2] * multiplier * cos(angle3) -
					   arrow3[i][0] * multiplier * sin(angle3)));
			glVertex3f((float) (- arrow3[i+1][0] * multiplier * cos(angle3) 
					   - arrow3[i+1][2] * multiplier * sin(angle3)),
					   (float) (arrow3[i+1][1] * multiplier + delta3),
					   (float) (arrow3[i+1][2] * multiplier * cos(angle3) -
					   arrow3[i+1][0] * multiplier * sin(angle3)));
		}

		last = arrow4Count - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f((float) (arrow4[i][0] * multiplier), 
					   (float) (arrow4[i][1] * multiplier + delta4), 
					   (float) (arrow4[i][2] * multiplier));
			glVertex3f((float) (arrow4[i+1][0] * multiplier), 
					   (float) (arrow4[i+1][1] * multiplier + delta4), 
					   (float) (arrow4[i+1][2] * multiplier));
		}

		last = perimeterCount - 1;
	    for (i = 0; i < last; ++i) { 
			glVertex3f(perimeter[i][0] * multiplier, 
					   perimeter[i][1] * multiplier, 
					   perimeter[i][2] * multiplier);
			glVertex3f(perimeter[i+1][0] * multiplier, 
					   perimeter[i+1][1] * multiplier, 
					   perimeter[i+1][2] * multiplier);
		}

	glEnd();

	view.endGL();
}
Пример #4
0
void title() {
	if (title_init == 0) {
		title_init = 1;
		alSourcePlay(opening_music->source);

		target->y = 0;
		target->x = 0;
		target->z = 0;

		eye->y = 0;
		eye->x = 0;
		eye->z = 1000;
		frame = 0;

		opening_init = 0;

		player->nengetu = 12;

		wcscpy(suezo->waza[0]->name, L"つばはき");
		wcscpy(suezo->waza[1]->name, L"しっぽアタック");
		wcscpy(monorisu->waza[0]->name, L"ビーム");
		wcscpy(monorisu->waza[1]->name, L"たおれこみ");

		suezo->waza[0]->image = tuba_image;
		suezo->waza[1]->image = sippo_image;
		monorisu->waza[0]->image = biimu_image;
		monorisu->waza[1]->image = taore_image;

		wcscpy(suezo->name, L"すえぞー");
		wcscpy(monorisu->name, L"ものりす");


		monster = suezo;

		enemy = monorisu;

		monster->type = game::PLAYER;
		enemy->type = game::ENEMY;

	}

	glColor4f(1, 1, 1, 1);
	title_background_image->changeImage();
	glBegin(GL_QUADS);
	{
		glTexCoord2f(0.f, 0.f);
		glVertex2f(-430.f, 430.f);
		glTexCoord2f(0.f, 1.f);
		glVertex2f(-430.f, -430.f);
		glTexCoord2f(1.f, 1.f);
		glVertex2f(430.f, -430.f);
		glTexCoord2f(1.f, 0.f);
		glVertex2f(430.f, 430.f);
	}
	glEnd();



	title_image->changeImage();

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

	glPushMatrix();
	if (frame < 200) {
		if (lkn::InputManager::getInstance()->keyPless(0x0d)) {
			frame = 200;
		}
		title_movie = 200 + (400 - frame * 2);
	}
	glTranslatef(0, title_movie, 0);
	glBegin(GL_QUADS);
	{
		glTexCoord2f(0.f, 0.f);
		glVertex2f(-250.f, 250.f);
		glTexCoord2f(0.f, 1.f);
		glVertex2f(-250.f, -250.f);
		glTexCoord2f(1.f, 1.f);
		glVertex2f(250.f, -250.f);
		glTexCoord2f(1.f, 0.f);
		glVertex2f(250.f, 250.f); 	}
	glEnd();
	glPopMatrix();

	if (frame >= 200) {
		if (lkn::InputManager::getInstance()->keyPless('w')) {
			alSourcePlay(select_music->source);
			title_count++;
		}
		if (lkn::InputManager::getInstance()->keyPless('s')) {
			alSourcePlay(select_music->source);
			title_count++;
		}
		title_count = (TITLE_MAX + title_count) % TITLE_MAX;

		glBlendFunc(
			GL_ONE,
			GL_ONE
			);
		float hajimekara = (1 - title_count)*0.3f + 0.1f;
		float owari = title_count * 0.3f + 0.1f;
		glDisable(GL_TEXTURE);
		glColor4f(hajimekara, hajimekara, hajimekara, 1);
		glBegin(GL_QUADS);
		{
			glVertex2f(-70.f, -140.f);
			glVertex2f(70.f, -140.f);
			glVertex2f(70.f, -210.f);
			glVertex2f(-70.f, -210.f);
		}
		glColor4f(owari, owari, owari, 1);
		{
			glVertex2f(-70.f, -212.f);
			glVertex2f(70.f, -212.f);
			glVertex2f(70.f, -282.f);
			glVertex2f(-70.f, -282.f);
		}
		glEnd();
		glDisable(GL_BLEND);
		glColor3f(0.3f, 0.3f, 0.3f);
		font->ChangeSize(lkn::TYPE_NORMAL);
		font->DrawStringW(-67, -200, L" はじめから");
		font->DrawStringW(-67, -270, L" EXIT");

		if (lkn::InputManager::getInstance()->keyPless(0x0d)) {
			if (title_count == TITLE_START) {
				alSourcePlay(decision_music->source);
				alSourceStop(opening_music->source);
				title_init = 0;
				func = opening;
			}
			else if (title_count == TITLE_EXIT) {
				alSourcePlay(decision_music->source);
				exit(0);
			}
		}
	}

	glMatrixMode(GL_PROJECTION);          /* 投影変換行列の設定 */
	glLoadIdentity();                     /* 変換行列の初期化 */
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glOrtho(
		0,//GLdouble left,
		300,//GLdouble right,
		0,//GLdouble bottom,
		300,//GLdouble top,
		1,//GLdouble zNear, 
		-1//GLdouble zFar
		);

	glColor3f(0, 0, 0);
	min_font->ChangeSize(lkn::TYPE_MIN);
	min_font->DrawStringW(10, 285, L"w:↑ s:↓ Enter:決定");
}
Пример #5
0
/*****************************************************************************
 * Draw a faceted latitude band of the Boing ball.
 *
 * Parms:   long_lo, long_hi
 *          Low and high longitudes of slice, resp.
 *****************************************************************************/
void DrawBoingBallBand( GLfloat long_lo,
                        GLfloat long_hi )
{
   vertex_t vert_ne;            /* "ne" means south-east, so on */
   vertex_t vert_nw;
   vertex_t vert_sw;
   vertex_t vert_se;
   vertex_t vert_norm;
   GLfloat  lat_deg;
   static int colorToggle = 0;

  /*
   * Iterate thru the points of a latitude circle.
   * A latitude circle is a 2D set of X,Z points.
   */
   for ( lat_deg = 0;
         lat_deg <= (360 - STEP_LATITUDE);
         lat_deg += STEP_LATITUDE )
   {
     /*
      * Color this polygon with red or white.
      */
      if ( colorToggle )
         glColor3f( 0.8, 0.1, 0.1 );
      else
         glColor3f( 0.95, 0.95, 0.95 );
#if 0
      if ( lat_deg >= 180 )
         if ( colorToggle )
            glColor3f( 0.1, 0.8, 0.1 );
         else
            glColor3f( 0.5, 0.5, 0.95 );
#endif
      colorToggle = ! colorToggle;

     /*
      * Change color if drawing shadow.
      */
      if ( drawBallHow == DRAW_BALL_SHADOW )
         glColor3f( 0.35, 0.35, 0.35 );

     /*
      * Assign each Y.
      */
      vert_ne.y = vert_nw.y = cos_deg(long_hi) * RADIUS;
      vert_sw.y = vert_se.y = cos_deg(long_lo) * RADIUS;

     /*
      * Assign each X,Z with sin,cos values scaled by latitude radius indexed by longitude.
      * Eg, long=0 and long=180 are at the poles, so zero scale is sin(longitude),
      * while long=90 (sin(90)=1) is at equator.
      */
      vert_ne.x = cos_deg( lat_deg                 ) * (RADIUS * sin_deg( long_lo + STEP_LONGITUDE ));
      vert_se.x = cos_deg( lat_deg                 ) * (RADIUS * sin_deg( long_lo                  ));
      vert_nw.x = cos_deg( lat_deg + STEP_LATITUDE ) * (RADIUS * sin_deg( long_lo + STEP_LONGITUDE ));
      vert_sw.x = cos_deg( lat_deg + STEP_LATITUDE ) * (RADIUS * sin_deg( long_lo                  ));

      vert_ne.z = sin_deg( lat_deg                 ) * (RADIUS * sin_deg( long_lo + STEP_LONGITUDE ));
      vert_se.z = sin_deg( lat_deg                 ) * (RADIUS * sin_deg( long_lo                  ));
      vert_nw.z = sin_deg( lat_deg + STEP_LATITUDE ) * (RADIUS * sin_deg( long_lo + STEP_LONGITUDE ));
      vert_sw.z = sin_deg( lat_deg + STEP_LATITUDE ) * (RADIUS * sin_deg( long_lo                  ));

     /*
      * Draw the facet.
      */
      glBegin( GL_POLYGON );

      CrossProduct( vert_ne, vert_nw, vert_sw, &vert_norm );
      glNormal3f( vert_norm.x, vert_norm.y, vert_norm.z );

      glVertex3f( vert_ne.x, vert_ne.y, vert_ne.z );
      glVertex3f( vert_nw.x, vert_nw.y, vert_nw.z );
      glVertex3f( vert_sw.x, vert_sw.y, vert_sw.z );
      glVertex3f( vert_se.x, vert_se.y, vert_se.z );

      glEnd();

#if BOING_DEBUG
      printf( "----------------------------------------------------------- \n" );
      printf( "lat = %f  long_lo = %f  long_hi = %f \n", lat_deg, long_lo, long_hi );
      printf( "vert_ne  x = %.8f  y = %.8f  z = %.8f \n", vert_ne.x, vert_ne.y, vert_ne.z );
      printf( "vert_nw  x = %.8f  y = %.8f  z = %.8f \n", vert_nw.x, vert_nw.y, vert_nw.z );
      printf( "vert_se  x = %.8f  y = %.8f  z = %.8f \n", vert_se.x, vert_se.y, vert_se.z );
      printf( "vert_sw  x = %.8f  y = %.8f  z = %.8f \n", vert_sw.x, vert_sw.y, vert_sw.z );
#endif

   }

  /*
   * Toggle color so that next band will opposite red/white colors than this one.
   */
   colorToggle = ! colorToggle;

  /*
   * This circular band is done.
   */
   return;
}
Пример #6
0
/* glmDraw: Renders the model to the current OpenGL context using the
 * mode specified.
 *
 * model    - initialized GLMmodel structure
 * mode     - a bitwise OR of values describing what is to be rendered.
 *            GLM_NONE     -  render with only vertices
 *            GLM_FLAT     -  render with facet normals
 *            GLM_SMOOTH   -  render with vertex normals
 *            GLM_TEXTURE  -  render with texture coords
 *            GLM_COLOR    -  render with colors (color material)
 *            GLM_MATERIAL -  render with materials
 *            GLM_COLOR and GLM_MATERIAL should not both be specified.  
 *            GLM_FLAT and GLM_SMOOTH should not both be specified.  
 */
GLvoid
glmDraw(GLMmodel* model, GLuint mode)
{
  GLuint i;
  GLMgroup* group;

  assert(model);
  assert(model->vertices);

  /* do a bit of warning */
  if (mode & GLM_FLAT && !model->facetnorms) {
    printf("glmDraw() warning: flat render mode requested "
	   "with no facet normals defined.\n");
    mode &= ~GLM_FLAT;
  }
  if (mode & GLM_SMOOTH && !model->normals) {
    printf("glmDraw() warning: smooth render mode requested "
	   "with no normals defined.\n");
    mode &= ~GLM_SMOOTH;
  }
  if (mode & GLM_TEXTURE && !model->texcoords) {
    printf("glmDraw() warning: texture render mode requested "
	   "with no texture coordinates defined.\n");
    mode &= ~GLM_TEXTURE;
  }
  if (mode & GLM_FLAT && mode & GLM_SMOOTH) {
    printf("glmDraw() warning: flat render mode requested "
	   "and smooth render mode requested (using smooth).\n");
    mode &= ~GLM_FLAT;
  }
  if (mode & GLM_COLOR && !model->materials) {
    printf("glmDraw() warning: color render mode requested "
	   "with no materials defined.\n");
    mode &= ~GLM_COLOR;
  }
  if (mode & GLM_MATERIAL && !model->materials) {
    printf("glmDraw() warning: material render mode requested "
	   "with no materials defined.\n");
    mode &= ~GLM_MATERIAL;
  }
  if (mode & GLM_COLOR && mode & GLM_MATERIAL) {
    printf("glmDraw() warning: color and material render mode requested "
	   "using only material mode\n");
    mode &= ~GLM_COLOR;
  }
  if (mode & GLM_COLOR)
    glEnable(GL_COLOR_MATERIAL);
  if (mode & GLM_MATERIAL)
    glDisable(GL_COLOR_MATERIAL);

  glPushMatrix();
  glTranslatef(model->position[0], model->position[1], model->position[2]);

  glBegin(GL_TRIANGLES);
  group = model->groups;
  while (group) {
    if (mode & GLM_MATERIAL) {
      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, 
		   model->materials[group->material].ambient);
      glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, 
		   model->materials[group->material].diffuse);
      glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, 
		   model->materials[group->material].specular);
       glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 
  		  model->materials[group->material].shininess);
    }

    if (mode & GLM_COLOR) {
      glColor3fv(model->materials[group->material].diffuse);
    }

    for (i = 0; i < group->numtriangles; i++) {
      if (mode & GLM_FLAT)
	glNormal3fv(&model->facetnorms[3 * T(group->triangles[i]).findex]);
      
      if (mode & GLM_SMOOTH)
	glNormal3fv(&model->normals[3 * T(group->triangles[i]).nindices[0]]);
      if (mode & GLM_TEXTURE)
	glTexCoord2fv(&model->texcoords[2*T(group->triangles[i]).tindices[0]]);
      glVertex3fv(&model->vertices[3 * T(group->triangles[i]).vindices[0]]);
#if 0
      printf("%f %f %f\n", 
	     model->vertices[3 * T(group->triangles[i]).vindices[0] + X],
	     model->vertices[3 * T(group->triangles[i]).vindices[0] + Y],
	     model->vertices[3 * T(group->triangles[i]).vindices[0] + Z]);
#endif
      
      if (mode & GLM_SMOOTH)
	glNormal3fv(&model->normals[3 * T(group->triangles[i]).nindices[1]]);
      if (mode & GLM_TEXTURE)
	glTexCoord2fv(&model->texcoords[2*T(group->triangles[i]).tindices[1]]);
      glVertex3fv(&model->vertices[3 * T(group->triangles[i]).vindices[1]]);
#if 0
      printf("%f %f %f\n", 
	     model->vertices[3 * T(group->triangles[i]).vindices[1] + X],
	     model->vertices[3 * T(group->triangles[i]).vindices[1] + Y],
	     model->vertices[3 * T(group->triangles[i]).vindices[1] + Z]);
#endif
      
      if (mode & GLM_SMOOTH)
	glNormal3fv(&model->normals[3 * T(group->triangles[i]).nindices[2]]);
      if (mode & GLM_TEXTURE)
	glTexCoord2fv(&model->texcoords[2*T(group->triangles[i]).tindices[2]]);
      glVertex3fv(&model->vertices[3 * T(group->triangles[i]).vindices[2]]);
#if 0
      printf("%f %f %f\n", 
	     model->vertices[3 * T(group->triangles[i]).vindices[2] + X],
	     model->vertices[3 * T(group->triangles[i]).vindices[2] + Y],
	     model->vertices[3 * T(group->triangles[i]).vindices[2] + Z]);
#endif
      
    }
    
    group = group->next;
  }
  glEnd();

  glPopMatrix();
}
Пример #7
0
void ofxCamMapper::drawPanel(int x,int y){
	ofEnableBlendMode(OF_BLENDMODE_ALPHA);
	ofPushMatrix();
	ofTranslate(x, y);
	
	//カメラポジションの描画
	ofSetHexColor(0xFFFFFF);
	ofEnableBlendMode(OF_BLENDMODE_ALPHA);
	
	ofPushMatrix();
	ofTranslate(camWin_pos.x,camWin_pos.y);
	//camera.draw(0,0, camWin_pos.width, camWin_pos.height);
	for (int i = 0;i < cam_pts.size();i++){
		ofPoint draw_pt = ofPoint(cam_pts[i].x/CAM_WIDTH*camWin_pos.width,
								  cam_pts[i].y/CAM_HEIGHT*camWin_pos.height);
		if (i >= (*out_pts).size()){
			ofLine(draw_pt.x-3, draw_pt.y, draw_pt.x+3, draw_pt.y);
			ofLine(draw_pt.x, draw_pt.y-3, draw_pt.x, draw_pt.y+3);			
		}
	}
	ofPopMatrix();
	
	main_scroll.set(MAX(0,MIN(ofGetMouseX(),BUFFER_WIDTH-1024.0)),
					MAX(0,MIN(ofGetMouseY(),BUFFER_HEIGHT-768)));
	
	
	//メインアウトポジションの描画
	ofSetHexColor(0xFFFFFF);
	ofPushMatrix();
	ofTranslate(vert_child.drawArea.x,vert_child.drawArea.y);
	if (vert_child.enableScroll){
		Buffer_out.getTextureReference().bind();
		glBegin(GL_TRIANGLE_STRIP);
		glTexCoord2f(vert_child.sclPt.x,vert_child.sclPt.y);
		glVertex2f(0, 0);
		glTexCoord2f(vert_child.sclPt.x+vert_child.drawArea.width,vert_child.sclPt.y);
		glVertex2f(vert_child.drawArea.width, 0);
		glTexCoord2f(vert_child.sclPt.x,vert_child.sclPt.y+vert_child.drawArea.height);
		glVertex2f(0, vert_child.drawArea.height);
		glTexCoord2f(vert_child.sclPt.x+vert_child.drawArea.width,vert_child.sclPt.y+vert_child.drawArea.height);
		glVertex2f(vert_child.drawArea.width,vert_child.drawArea.height);
		glEnd();
		Buffer_out.getTextureReference().unbind();
	}else{
		Buffer_out.draw(0, 0,vert_child.drawArea.width,vert_child.drawArea.height);
	}
	if (drawChild){
		vert_child.draw();
	}
	ofPopMatrix();

	//ソースポジションの描画
	ofSetHexColor(0xFFFFFF);
	ofPushMatrix();
	ofTranslate(src_editor.drawArea.x,src_editor.drawArea.y);
	if (src_editor.enableScroll){
		Buffer_src.getTextureReference().bind();
		glBegin(GL_TRIANGLE_STRIP);
		glTexCoord2f(src_editor.sclPt.x,src_editor.sclPt.y);
		glVertex2f(0, 0);
		glTexCoord2f(src_editor.sclPt.x+src_editor.drawArea.width,src_editor.sclPt.y);
		glVertex2f(src_editor.drawArea.width, 0);
		glTexCoord2f(src_editor.sclPt.x,src_editor.sclPt.y+src_editor.drawArea.height);
		glVertex2f(0, src_editor.drawArea.height);
		glTexCoord2f(src_editor.sclPt.x+src_editor.drawArea.width,src_editor.sclPt.y+src_editor.drawArea.height);
		glVertex2f(src_editor.drawArea.width,src_editor.drawArea.height);
		glEnd();
		Buffer_src.getTextureReference().unbind();
	}else{
		Buffer_src.draw(0, 0,src_editor.drawArea.width,src_editor.drawArea.height);
	}
	for (int i = 0;i < src_pts.size();i++){
		ofCircle(src_pts[i].x, src_pts[i].y, 3);
	}
	ofPopMatrix();
	if (drawChild){
		src_editor.draw();
	}
	ofPopMatrix();
	
	
	//マスクの描画
	ofSetHexColor(0xFFFFFF);
	ofPushMatrix();
	ofTranslate(mask.drawArea.x, mask.drawArea.y);
	if (mask.enableScroll){
		Buffer_out.getTextureReference().bind();
		glBegin(GL_TRIANGLE_STRIP);
		glTexCoord2f(mask.sclPt.x,mask.sclPt.y);
		glVertex2f(0, 0);
		glTexCoord2f(mask.sclPt.x+mask.drawArea.width,mask.sclPt.y);
		glVertex2f(mask.drawArea.width, 0);
		glTexCoord2f(mask.sclPt.x,mask.sclPt.y+mask.drawArea.height);
		glVertex2f(0, mask.drawArea.height);
		glTexCoord2f(mask.sclPt.x+mask.drawArea.width,mask.sclPt.y+mask.drawArea.height);
		glVertex2f(mask.drawArea.width,mask.drawArea.height);
		glEnd();
		Buffer_out.getTextureReference().unbind();
	}
	if (drawChild){
		mask.draw();		
	}
	ofPopMatrix();
	
	//キャリブレーション表示
	ofPushMatrix();
	ofTranslate(BUFFER_WIDTH, 0);
	ofSetColor(sampleColor);
	ofRect(0, 480, 40, 40);
	ofSetColor(trackingColor);
	ofRect(40, 480, 40, 40);
	string info = "";
	info += "Score: " + ofToString(color_score) + "/" + ofToString(Genframe) + "\n";
	info += "Size:" + ofToString(size) + "\n";
	info += "Elapsed:" + ofToString(ofGetElapsedTimeMillis() - calib_waiter) + "\n";
	
	ofDrawBitmapString(info, 10,540);
	
	if ((abs(trackingColor.r - sampleColor.r) < 100)&&
		(abs(trackingColor.g - sampleColor.g) < 100)&&
		(abs(trackingColor.b - sampleColor.b) < 100)){
		ofNoFill();
		ofSetHexColor(0xFFFFFF);
		ofRect(0, 480, 80, 40);
		ofFill();
	}
	ofPopMatrix();
	menu.draw();
	ofSetHexColor(0xFFFF00);
	ofLine(SelectedPt.x-5, SelectedPt.y, SelectedPt.x+5, SelectedPt.y);
	ofLine(SelectedPt.x, SelectedPt.y-5, SelectedPt.x, SelectedPt.y+5);
	
	vector<string> PresetBranch;
	PresetBranch.push_back("Msk_Preset0");
	PresetBranch.push_back("Msk_Preset1");
	PresetBranch.push_back("Msk_Preset2");
	PresetBranch.push_back("Msk_Preset3");
	PresetBranch.push_back("Msk_Preset4");
	PresetBranch.push_back("Msk_Preset5");
	PresetBranch.push_back("Msk_Preset6");
	PresetBranch.push_back("Msk_Preset7");
	PresetBranch.push_back("Msk_Preset8");
	PresetBranch.push_back("Msk_Preset9");
	mask.menu.UnRegisterMenu("Save");
	mask.menu.RegisterBranch("Save", &PresetBranch);
}
Пример #8
0
void draw_tile_map()
{
	int x_start,x_end,y_start,y_end;
	int x,y;
	float x_scaled,y_scaled;

	//get only the tiles around the camera
	//we have the axes inverted, btw the go from 0 to -255
	if(camera_x<0)x=(int)(camera_x*-1)/3;
	else x=(int)camera_x/3;
	if(camera_y<0)y=(int)(camera_y*-1)/3;
	else y=(int)camera_y/3;
	x_start=x-(int)zoom_level;
	y_start=y-(int)zoom_level;
	x_end=x+(int)zoom_level;
	y_end=y+(int)zoom_level;
	if(x_start<0)x_start=0;
	if(x_end>=tile_map_size_x)x_end=tile_map_size_x-1;
	if(y_start<0)y_start=0;
	if(y_end>=tile_map_size_y)y_end=tile_map_size_y-1;
	if(!have_multitexture || poor_man)
		{
			for(y=y_start;y<=y_end;y++)
				{
					y_scaled=y*3.0f;
					for(x=x_start;x<=x_end;x++)
						{
							x_scaled=x*3.0f;
							if(is_water_tile(tile_map[y*tile_map_size_x+x]))continue;//lake, skip
							if(tile_map[y*tile_map_size_x+x]==255){
								/*glDisable(GL_TEXTURE_2D);
								glDisable(GL_LIGHTING);
								glBegin(GL_QUADS);
								glColor3f(0.2,0.2,0.2);
				 				glVertex3f(x_scaled,y_scaled+3, -3.0f);
								glVertex3f(x_scaled,y_scaled, -3.0f);
								glVertex3f(x_scaled+3, y_scaled,-3.0f);
								glVertex3f(x_scaled+3, y_scaled+3,-3.0f);
								glColor3f(1.0,1.0,1.0);
				 				glEnd();
								glEnable(GL_LIGHTING);
								glEnable(GL_TEXTURE_2D);*/
								continue;
							}//null, skip
							bind_texture(tile_list[tile_map[y*tile_map_size_x+x]]);
							glBegin(GL_QUADS);
 							glTexCoord2f(0, 0.0f);
			 				glVertex3f(x_scaled,y_scaled+3, 0.0f);
							glTexCoord2f(0, 1.0f);
							glVertex3f(x_scaled,y_scaled, 0.0f);
							glTexCoord2f(1.0f, 1.0f);
							glVertex3f(x_scaled+3, y_scaled,0.0f);
							glTexCoord2f(1.0f, 0.0f);
							glVertex3f(x_scaled+3, y_scaled+3,0.0f);
							glEnd();
						}
				}
		}
	else//we draw the ground details
		{
			//bind the detail texture
			glActiveTextureARB(GL_TEXTURE1_ARB);
			glEnable(GL_TEXTURE_2D);
			bind_texture_unbuffered(ground_detail_text);
			glActiveTextureARB(GL_TEXTURE0_ARB);
			glEnable(GL_TEXTURE_2D);

			for(y=y_start;y<=y_end;y++)
				{
					y_scaled=y*3.0f;
					for(x=x_start;x<=x_end;x++)
						{
							x_scaled=x*3.0f;
							if(is_water_tile(tile_map[y*tile_map_size_x+x]))continue;//lake, skip
							if(tile_map[y*tile_map_size_x+x]==255){
								/*glDisable(GL_TEXTURE_2D);
								glDisable(GL_LIGHTING);
								glBegin(GL_QUADS);
								glColor3f(0.2,0.2,0.2);
				 				glVertex3f(x_scaled,y_scaled+3, -3.0f);
								glVertex3f(x_scaled,y_scaled, -3.0f);
								glVertex3f(x_scaled+3, y_scaled,-3.0f);
								glVertex3f(x_scaled+3, y_scaled+3,-3.0f);
								glColor3f(1.0,1.0,1.0);
				 				glEnd();
								glEnable(GL_LIGHTING);
								glEnable(GL_TEXTURE_2D);*/
								continue;
							}//null, skip
							bind_texture(tile_list[tile_map[y*tile_map_size_x+x]]);
							//draw our normal tile
							glBegin(GL_QUADS);
 							glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0, 0.0f);
 							glMultiTexCoord2fARB(GL_TEXTURE1_ARB,x_scaled/texture_scale+clouds_movement_u, (y_scaled+3.0)/texture_scale+clouds_movement_v);
			 				glVertex3f(x_scaled,y_scaled+3, 0.0f);

							glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0, 1.0f);
							glMultiTexCoord2fARB(GL_TEXTURE1_ARB,x_scaled/texture_scale+clouds_movement_u, y_scaled/texture_scale+clouds_movement_v);
							glVertex3f(x_scaled,y_scaled, 0.0f);

							glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1.0f, 1.0f);
							glMultiTexCoord2fARB(GL_TEXTURE1_ARB,(x_scaled+3.0f)/texture_scale+clouds_movement_u, y_scaled/texture_scale+clouds_movement_v);
							glVertex3f(x_scaled+3, y_scaled,0.0f);

							glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1.0f, 0.0f);
							glMultiTexCoord2fARB(GL_TEXTURE1_ARB,(x_scaled+3.0)/texture_scale+clouds_movement_u, (y_scaled+3.0)/texture_scale+clouds_movement_v);
							glVertex3f(x_scaled+3, y_scaled+3,0.0f);
							glEnd();
						}
				}
			//disable the second texture unit
			glActiveTextureARB(GL_TEXTURE1_ARB);
			glDisable(GL_TEXTURE_2D);
			glActiveTextureARB(GL_TEXTURE0_ARB);

		}

}
Пример #9
0
void DeferredLighting::SpotLightPass()
{
	// Active differents buffers
	m_FBO_graphics->GetTexture("Diffuse")->activateMultiTex(CUSTOM_TEXTURE + 0);
	m_FBO_graphics->GetTexture("Specular")->activateMultiTex(
			CUSTOM_TEXTURE + 1);
	m_FBO_graphics->GetTexture("Normal")->activateMultiTex(CUSTOM_TEXTURE + 2);
	m_FBO_graphics->GetTexture("Depth")->activateMultiTex(CUSTOM_TEXTURE + 3);

	// Update Info
	m_spot_light_shader->Begin();
	ShaderHelperUniformPositionFromView(m_spot_light_shader);
	m_spot_light_shader->End();

	for (int i = 0; i < m_spots_lights.size(); i++)
	{
		// Generate the Shadow Map
		// * Transformations
		Math::CMatrix4 oldProjectionMatrix =
				CMatrixManager::Instance().GetMatrix(PROJECTION_MATRIX);
		Math::CMatrix4 oldViewMatrix = CMatrixManager::Instance().GetMatrix(
				VIEW_MATRIX);
		Math::CMatrix4 LightViewMatrix;
		LightViewMatrix.LookAt(m_spots_lights[i].Position,
				m_spots_lights[i].Direction);
		Math::CMatrix4 LightProjectionMatrix;
		CMatrixManager::Instance().SetProjectionMatrix(
				Math::CMatrix4::CreatePerspectiveFOV(
						m_spots_lights[i].LightCutOff, 512.0 / 512.0, 1.0,
						m_spots_lights[i].LightRaduis));
		CMatrixManager::Instance().SetViewMatrix(LightViewMatrix);
		// * Draw the scene
//		glEnable(GL_CULL_FACE);
//		glCullFace(GL_BACK);
		m_simple_shader->Begin();
		CSceneManager::Instance().RenderAll(); // Draw the scene
		m_simple_shader->End();
//		glDisable(GL_CULL_FACE);
		// * Revert transformations
		CMatrixManager::Instance().SetProjectionMatrix(oldProjectionMatrix);
		CMatrixManager::Instance().SetViewMatrix(oldViewMatrix);
		// * Give Depth Texture
		m_simple_shader->GetFBO()->GetTexture("Depth")->activateMultiTex(
				CUSTOM_TEXTURE + 4);

//		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		// Go to spot pass
		m_spot_light_shader->Begin();
		// * Light propreties
		m_spot_light_shader->SetUniform1f("LightRaduis",
				m_spots_lights[i].LightRaduis);
		m_spot_light_shader->SetUniform1f("LightCutOff",
				cos(m_spots_lights[i].LightCutOff * (M_PI / 180.0)));
		m_spot_light_shader->SetUniform1f("LightIntensity",
				m_spots_lights[i].LightIntensity);
		m_spot_light_shader->SetUniformVector("LightPosition",
				m_spots_lights[i].Position);
		m_spot_light_shader->SetUniformVector("LightSpotDirection",
				m_spots_lights[i].Direction);
		m_spot_light_shader->SetUniformColor("LightColor",
				m_spots_lights[i].LightColor);
		// * Shadow Map propreties
		m_spot_light_shader->SetUniformMatrix4fv("LightViewMatrix",
				LightViewMatrix);
		m_spot_light_shader->SetUniformMatrix4fv("LightProjectionMatrix",
				LightProjectionMatrix);
		// Draw ...
		glBegin(GL_QUADS);
		glTexCoord2f(0.0, 0.0);
		glVertex2f(-1.0, -1.0);
		glTexCoord2f(0.0, 1.0);
		glVertex2f(-1.0, 1.0);
		glTexCoord2f(1.0, 1.0);
		glVertex2f(1.0, 1.0);
		glTexCoord2f(1.0, 0.0);
		glVertex2f(1.0, -1.0);
		glEnd();

		m_spot_light_shader->End();
	}

	// Desactive differents buffers
	m_FBO_graphics->GetTexture("Diffuse")->desactivateMultiTex(
			CUSTOM_TEXTURE + 0);
	m_FBO_graphics->GetTexture("Specular")->desactivateMultiTex(
			CUSTOM_TEXTURE + 1);
	m_FBO_graphics->GetTexture("Normal")->desactivateMultiTex(
			CUSTOM_TEXTURE + 2);
	m_FBO_graphics->GetTexture("Depth")->desactivateMultiTex(
			CUSTOM_TEXTURE + 3);
	m_simple_shader->GetFBO()->GetTexture("Depth")->desactivateMultiTex(
			CUSTOM_TEXTURE + 4);
}
Пример #10
0
/// Draw the shadow for a shape
static void pie_DrawShadow(iIMDShape *shape, int flag, int flag_data, Vector3f* light)
{
	unsigned int i, j, n;
	Vector3f *pVertices;
	iIMDPoly *pPolys;
	static std::vector<EDGE> edgelist;  // Static, to save allocations.
	static std::vector<EDGE> edgelistFlipped;  // Static, to save allocations.
	static std::vector<EDGE> edgelistFiltered;  // Static, to save allocations.
	EDGE *drawlist = NULL;

	unsigned edge_count;
	pVertices = shape->points;
	if( flag & pie_STATIC_SHADOW && shape->shadowEdgeList )
	{
		drawlist = shape->shadowEdgeList;
		edge_count = shape->nShadowEdges;
	}
	else
	{
		edgelist.clear();
		for (i = 0, pPolys = shape->polys; i < shape->npolys; ++i, ++pPolys)
		{
			Vector3f p[3];
			for(j = 0; j < 3; j++)
			{
				int current = pPolys->pindex[j];
				p[j] = Vector3f(pVertices[current].x, scale_y(pVertices[current].y, flag, flag_data), pVertices[current].z);
			}

			Vector3f normal = crossProduct(p[2] - p[0], p[1] - p[0]);
			if (normal * *light > 0)
			{
				for (n = 1; n < pPolys->npnts; n++)
				{
					// link to the previous vertex
					addToEdgeList(pPolys->pindex[n-1], pPolys->pindex[n], edgelist);
				}
				// back to the first
				addToEdgeList(pPolys->pindex[pPolys->npnts-1], pPolys->pindex[0], edgelist);
			}
		}

		// Remove duplicate pairs from the edge list. For example, in the list ((1 2), (2 6), (6 2), (3, 4)), remove (2 6) and (6 2).
		edgelistFlipped = edgelist;
		std::for_each(edgelistFlipped.begin(), edgelistFlipped.end(), flipEdge);
		std::sort(edgelist.begin(), edgelist.end(), edgeLessThan);
		std::sort(edgelistFlipped.begin(), edgelistFlipped.end(), edgeLessThan);
		edgelistFiltered.resize(edgelist.size());
		edgelistFiltered.erase(std::set_difference(edgelist.begin(), edgelist.end(), edgelistFlipped.begin(), edgelistFlipped.end(), edgelistFiltered.begin(), edgeLessThan), edgelistFiltered.end());

		drawlist = &edgelistFiltered[0];
		edge_count = edgelistFiltered.size();
		//debug(LOG_WARNING, "we have %i edges", edge_count);

		if(flag & pie_STATIC_SHADOW)
		{
			// then store it in the imd
			shape->nShadowEdges = edge_count;
			shape->shadowEdgeList = (EDGE *)realloc(shape->shadowEdgeList, sizeof(EDGE) * shape->nShadowEdges);
			std::copy(drawlist, drawlist + edge_count, shape->shadowEdgeList);
		}
	}

	// draw the shadow volume
	glBegin(GL_QUADS);
	glNormal3f(0.0, 1.0, 0.0);
	for(i=0;i<edge_count;i++)
	{
		int a = drawlist[i].from, b = drawlist[i].to;

		glVertex3f(pVertices[b].x, scale_y(pVertices[b].y, flag, flag_data), pVertices[b].z);
		glVertex3f(pVertices[b].x+light->x, scale_y(pVertices[b].y, flag, flag_data)+light->y, pVertices[b].z+light->z);
		glVertex3f(pVertices[a].x+light->x, scale_y(pVertices[a].y, flag, flag_data)+light->y, pVertices[a].z+light->z);
		glVertex3f(pVertices[a].x, scale_y(pVertices[a].y, flag, flag_data), pVertices[a].z);
	}
	glEnd();

#ifdef SHOW_SHADOW_EDGES
	glDisable(GL_DEPTH_TEST);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

	glColor4ub(0xFF, 0, 0, 0xFF);
	glBegin(GL_LINES);
	for(i = 0; i < edge_count; i++)
	{
		int a = drawlist[i].from, b = drawlist[i].to;
		if(a < 0)
		{
			continue;
		}

		glVertex3f(pVertices[b].x, scale_y(pVertices[b].y, flag, flag_data), pVertices[b].z);
		glVertex3f(pVertices[a].x, scale_y(pVertices[a].y, flag, flag_data), pVertices[a].z);
	}
	glEnd();
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glEnable(GL_DEPTH_TEST);
#endif
}
Пример #11
0
static void pie_DrawShadows(void)
{
	const float width = pie_GetVideoBufferWidth();
	const float height = pie_GetVideoBufferHeight();
	GLenum op_depth_pass_front = GL_INCR, op_depth_pass_back = GL_DECR;

	pie_SetTexturePage(TEXPAGE_NONE);

	glPushMatrix();

	pie_SetAlphaTest(false);
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDepthFunc(GL_LESS);
	glDepthMask(GL_FALSE);
	glEnable(GL_STENCIL_TEST);

	// Check if we have the required extensions
	if (GLEW_EXT_stencil_wrap)
	{
		op_depth_pass_front = GL_INCR_WRAP_EXT;
		op_depth_pass_back = GL_DECR_WRAP_EXT;
	}

	// generic 1-pass version
	if (GLEW_EXT_stencil_two_side)
	{
		glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
		glDisable(GL_CULL_FACE);
		glStencilMask(~0);
		glActiveStencilFaceEXT(GL_BACK);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
		glStencilFunc(GL_ALWAYS, 0, ~0);
		glActiveStencilFaceEXT(GL_FRONT);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
		glStencilFunc(GL_ALWAYS, 0, ~0);

		pie_ShadowDrawLoop();
		
		glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
	}
	// check for ATI-specific 1-pass version
	else if (GLEW_ATI_separate_stencil)
	{
		glDisable(GL_CULL_FACE);
		glStencilMask(~0);
		glStencilOpSeparateATI(GL_BACK, GL_KEEP, GL_KEEP, op_depth_pass_back);
		glStencilOpSeparateATI(GL_FRONT, GL_KEEP, GL_KEEP, op_depth_pass_front);
		glStencilFunc(GL_ALWAYS, 0, ~0);

		pie_ShadowDrawLoop();	
	}
	// fall back to default 2-pass version
	else
	{
		glStencilMask(~0);
		glStencilFunc(GL_ALWAYS, 0, ~0);
		glEnable(GL_CULL_FACE);
		
		// Setup stencil for front-facing polygons
		glCullFace(GL_BACK);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);

		pie_ShadowDrawLoop();

		// Setup stencil for back-facing polygons
		glCullFace(GL_FRONT);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);

		pie_ShadowDrawLoop();
	}

	pie_SetRendMode(REND_ALPHA);
	glEnable(GL_CULL_FACE);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	glStencilMask(~0);
	glStencilFunc(GL_LESS, 0, ~0);
	glColor4f(0, 0, 0, 0.5);

	pie_PerspectiveEnd();
	glLoadIdentity();
	glDisable(GL_DEPTH_TEST);
	glBegin(GL_TRIANGLE_STRIP);
		glVertex2f(0, 0);
		glVertex2f(width, 0);
		glVertex2f(0, height);
		glVertex2f(width, height);
	glEnd();
	pie_PerspectiveBegin();

	pie_SetRendMode(REND_OPAQUE);
	glDisable(GL_STENCIL_TEST);
	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);

	glPopMatrix();

	scshapes.clear();
}
Пример #12
0
static void pie_Draw3DShape2(iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, int pieFlag, int pieFlagData)
{
	iIMDPoly *pPolys;
	bool light = true;
	bool shaders = pie_GetShaderAvailability();

	pie_SetAlphaTest((pieFlag & pie_PREMULTIPLIED) == 0);

	/* Set fog status */
	if (!(pieFlag & pie_FORCE_FOG) && 
		(pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_BUTTON || pieFlag & pie_PREMULTIPLIED))
	{
		pie_SetFogStatus(false);
	}
	else
	{
		pie_SetFogStatus(true);
	}

	/* Set tranlucency */
	if (pieFlag & pie_ADDITIVE)
	{
		pie_SetRendMode(REND_ADDITIVE);
		colour.byte.a = (UBYTE)pieFlagData;
		light = false;
	}
	else if (pieFlag & pie_TRANSLUCENT)
	{
		pie_SetRendMode(REND_ALPHA);
		colour.byte.a = (UBYTE)pieFlagData;
		light = false;
	}
	else if (pieFlag & pie_PREMULTIPLIED)
	{
		pie_SetRendMode(REND_PREMULTIPLIED);
		light = false;
	}
	else
	{
		if (pieFlag & pie_BUTTON)
		{
			pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
			light = false;
			if (shaders)
			{
				pie_ActivateShader(SHADER_BUTTON, shape, teamcolour, colour);
			}
			else
			{
				pie_ActivateFallback(SHADER_BUTTON, shape, teamcolour, colour);
			}
		}
		pie_SetRendMode(REND_OPAQUE);
	}
	if (pieFlag & pie_ECM)
	{
		pie_SetRendMode(REND_ALPHA);
		light = true;
		pie_SetShaderEcmEffect(true);
	}

	if (light)
	{
		glMaterialfv(GL_FRONT, GL_AMBIENT, shape->material[LIGHT_AMBIENT]);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, shape->material[LIGHT_DIFFUSE]);
		glMaterialfv(GL_FRONT, GL_SPECULAR, shape->material[LIGHT_SPECULAR]);
		glMaterialf(GL_FRONT, GL_SHININESS, shape->shininess);
		glMaterialfv(GL_FRONT, GL_EMISSION, shape->material[LIGHT_EMISSIVE]);
		if (shaders)
		{
			pie_ActivateShader(SHADER_COMPONENT, shape, teamcolour, colour);
		}
		else
		{
			pie_ActivateFallback(SHADER_COMPONENT, shape, teamcolour, colour);
		}
	}

	if (pieFlag & pie_HEIGHT_SCALED)	// construct
	{
		glScalef(1.0f, (float)pieFlagData / (float)pie_RAISE_SCALE, 1.0f);
	}
	if (pieFlag & pie_RAISE)		// collapse
	{
		glTranslatef(1.0f, (-shape->max.y * (pie_RAISE_SCALE - pieFlagData)) * (1.0f / pie_RAISE_SCALE), 1.0f);
	}

	glColor4ubv(colour.vector);     // Only need to set once for entire model
	pie_SetTexturePage(shape->texpage);

	frame %= MAX(1, shape->numFrames);

	glBegin(GL_TRIANGLES);
	for (pPolys = shape->polys; pPolys < shape->polys + shape->npolys; pPolys++)
	{
		Vector3f	vertexCoords[3];
		unsigned int	n, frameidx = frame;
		int	*index;

		if (!(pPolys->flags & iV_IMD_TEXANIM))
		{
			frameidx = 0;
		}

		for (n = 0, index = pPolys->pindex;
				n < pPolys->npnts;
				n++, index++)
		{
			vertexCoords[n].x = shape->points[*index].x;
			vertexCoords[n].y = shape->points[*index].y;
			vertexCoords[n].z = shape->points[*index].z;
		}

		polyCount++;

		glNormal3fv((GLfloat*)&pPolys->normal);
		for (n = 0; n < pPolys->npnts; n++)
		{
			GLfloat* texCoord = (GLfloat*)&pPolys->texCoord[frameidx * pPolys->npnts + n];
			glTexCoord2fv(texCoord);
			if (!shaders)
			{
				glMultiTexCoord2fv(GL_TEXTURE1, texCoord);
			}
			glVertex3fv((GLfloat*)&vertexCoords[n]);
		}
	}
	glEnd();

	if (light || (pieFlag & pie_BUTTON))
	{
		if (shaders)
		{
			pie_DeactivateShader();
		}
		else
		{
			pie_DeactivateFallback();
		}
	}
	pie_SetShaderEcmEffect(false);

	if (pieFlag & pie_BUTTON)
	{
		pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
	}
}
Пример #13
0
int main( int argc, char **argv )
{
	
	SDL_Window* window = NULL;

	if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ){
		printf( "Unable to initialize SDL: %s\n",
			SDL_GetError() );
		return 1;
	}

	atexit( SDL_Quit );

	window = SDL_CreateWindow( "OpenGL with SDL2",
				   SDL_WINDOWPOS_UNDEFINED,
				   SDL_WINDOWPOS_UNDEFINED,
				   SCREEN_WIDTH, SCREEN_HEIGHT,
				   SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL );

	if ( !window ){
		printf( "Unable to create window, %s\n",
			SDL_GetError() );
		return 1;
	}

	SDL_GLContext glcontext = SDL_GL_CreateContext( window );

	if ( !glcontext ){

		printf( "Unable to create context, %s\n",
			SDL_GetError() );
		return 1;
	}

	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
	SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 6 );
	SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );

	glViewport( 80, 0, 480, 480 );
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
	glFrustum( -1.0, 1.0, -1.0, 1.0, 1.0, 100.0 );
	glClearColor( 0, 0, 0, 0 );
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
	glClear( GL_COLOR_BUFFER_BIT );

	glBegin( GL_TRIANGLES );
	glColor3f( 1.0, 0.0, 0.0 );
	glVertex3f( 0.0, 1.0, -2.0 );
	glColor3f( 0.0, 1.0, 0.0 );
	glVertex3f( 1.0, -1.0, -2.0 );
	glColor3f( 0.0, 0.0, 1.0 );
	glVertex3f( -1.0, -1.0, -2.0 );
	glEnd();

	glFlush();
	SDL_GL_SwapWindow( window );
	SDL_Delay( 5000 );
	
	SDL_GL_DeleteContext( glcontext );
	
	return 0;
}
Пример #14
0
void
gl_window_draw_grid(GtkGLArea *glarea)
{
  gl_window_info *info = gtk_object_get_data(GTK_OBJECT(glarea), "info");
  GLfloat top, left, right, bottom, x, y;
  static GLfloat line_spacing = 5;
  gint line_count, i;

  // don't draw grid for texture ball
  if(info->orientation == ORIENTATION_TEXTURE)
    return;

  line_count = (int) rintf(info->x_median / line_spacing) + 1;

  if(line_count > 10){
    line_spacing *= 2.0;
    line_count = (int) rintf(info->x_median / line_spacing) + 1;
  }else if(line_count < 6){
    line_spacing /= 2.0;
    line_count = (int) rintf(info->x_median / line_spacing) + 1;
  }

  /* set top, bottom, left and right ordinates */
  if(info->orientation == ORIENTATION_3D){

    /* in 3d mode, draw a grid on the Y = 0 plane */

    top = 0.90 * info->y_median;

    if(top < 10) top = 10;

    top -= fmod(top, line_spacing);
    bottom = -top;

    right = top;
    left  = bottom;

    line_count = rintf(right / line_spacing) + 1;
  }else{
    top    = info->y_median * -1;
    bottom = info->y_median;

    left   = info->x_median * -1;
    right  = info->x_median;
  }

  if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){
    glMatrixMode(GL_MODELVIEW);
    switch(info->orientation)
      {
      case ORIENTATION_FRONT:	break;
      case ORIENTATION_3D:	glRotatef(-90, 1,0,0);  break;
      case ORIENTATION_TOP:	glRotatef(-90, 1,0,0);	break;
      case ORIENTATION_BOTTOM:	glRotatef( 90, 1,0,0);	break;
      case ORIENTATION_LEFT:	glRotatef(90, 0,1,0);	break;
      case ORIENTATION_RIGHT:	glRotatef(-90, 0,1,0);	break;
      case ORIENTATION_BACK:	glRotatef(180, 0,1,0);	break;
      default: break;
      }

    glColor3f(0.3, 0.3, 0.3);
    glBegin(GL_LINES);

    /* draw x=0 z=0 line */
    glVertex3f( 0, top,    0 );
    glVertex3f( 0, bottom, 0 );

    /* draw y=0 z=0 line */
    glVertex3f( left,  0, 0 );
    glVertex3f( right, 0, 0 );

    for(i = 0; i < line_count; i++){

      y = line_spacing * i;
      x = y;

      glVertex3f( -x, top,    0 );
      glVertex3f( -x, bottom, 0 );

      glVertex3f( x, bottom, 0 );
      glVertex3f( x, top,    0 );

      glVertex3f( left,  y, 0 );
      glVertex3f( right, y, 0 );

      glVertex3f( right, -y, 0 );
      glVertex3f( left,  -y, 0 );
      
    }
    glEnd();

    switch(info->orientation)
      {
      case ORIENTATION_FRONT:	break;
      case ORIENTATION_3D:	glRotatef(90, 1,0,0);  break;
      case ORIENTATION_TOP:	glRotatef(90, 1,0,0);	break;
      case ORIENTATION_BOTTOM:	glRotatef(-90, 1,0,0);	break;
      case ORIENTATION_LEFT:	glRotatef(-90, 0,1,0);	break;
      case ORIENTATION_RIGHT:	glRotatef(90, 0,1,0);	break;
      case ORIENTATION_BACK:	glRotatef(180, 0,1,0);	break;
      default: break;
      }
  }


  return;
}
void intro_do(long t, long delta_time)
{
    char errorText[MAX_ERROR_LENGTH + 1];
    float ftime = 0.001f*(float)t;
    float fdelta_time = 0.001f * (float)(delta_time);
    GLuint textureID;

    glDisable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);

    // Those are key-Press indicators. I only act on 0-to-1.
    for (int i = 0; i < maxNumParameters; i++)
    {
        float destination_value = params.getParam(i, defaultParameters[i]);
        interpolatedParameters[i] = expf(-2.5f*fdelta_time) * interpolatedParameters[i] +
            (1.0f - expf(-2.5f*fdelta_time)) * destination_value;
    }
    // Update key press events.
    for (int i = 0; i < NUM_KEYS; i++)
    {
        if (params.getParam(i, 0.0) > 0.5f) keyPressed[i]++;
        else keyPressed[i] = 0;
    }

    // BPM => spike calculation
    float BPS = BPM / 60.0f;
    float jumpsPerSecond = BPS / 1.0f; // Jump on every fourth beat.
    static float phase = 0.0f;
    float jumpTime = (ftime * jumpsPerSecond) + phase;
    jumpTime -= (float)floor(jumpTime);
    if (keyPressed[41] == 1)
    {
        phase -= jumpTime;
        jumpTime = 0.0f;
        if (phase < 0.0f) phase += 1.0;
    }
    jumpTime = jumpTime * jumpTime;
    // spike is between 0.0 and 1.0 depending on the position within whatever.
    float spike = 0.5f * cosf(jumpTime * 3.1415926f * 1.5f) + 0.5f;
    // blob is growing down from 1. after keypress
    static float lastFTime = 0.f;
    blob *= (float)exp(-(float)(ftime - lastFTime) * BLOB_FADE_SPEED);
    lastFTime = ftime;

    // Set the program uniforms
    GLuint programID;
    shaderManager.getProgramID(usedProgram[usedIndex], &programID, errorText);
    glUseProgram(programID);
#if 1
    GLuint loc = glGetUniformLocation(programID, "aspectRatio");
    glUniform1f(loc, aspectRatio);
    loc = glGetUniformLocation(programID, "time");
    glUniform1f(loc, (float)(t * 0.001f));
    // For now I am just sending the spike to the shader. I might need something better...
    loc = glGetUniformLocation(programID, "spike");
    glUniform1f(loc, spike);
    loc = glGetUniformLocation(programID, "blob");
    glUniform1f(loc, blob);
    loc = glGetUniformLocation(programID, "knob1");
    glUniform1f(loc, interpolatedParameters[14]);
    loc = glGetUniformLocation(programID, "knob2");
    glUniform1f(loc, interpolatedParameters[15]);
    loc = glGetUniformLocation(programID, "knob3");
    glUniform1f(loc, interpolatedParameters[16]);
    loc = glGetUniformLocation(programID, "knob4");
    glUniform1f(loc, interpolatedParameters[17]);
    loc = glGetUniformLocation(programID, "knob5");
    glUniform1f(loc, interpolatedParameters[18]);
    loc = glGetUniformLocation(programID, "knob6");
    glUniform1f(loc, interpolatedParameters[19]);
    loc = glGetUniformLocation(programID, "knob7");
    glUniform1f(loc, interpolatedParameters[20]);
    loc = glGetUniformLocation(programID, "knob8");
    glUniform1f(loc, interpolatedParameters[21]);
    loc = glGetUniformLocation(programID, "knob9");
    glUniform1f(loc, interpolatedParameters[22]);
    loc = glGetUniformLocation(programID, "slider1");
    glUniform1f(loc, interpolatedParameters[2]);
    loc = glGetUniformLocation(programID, "slider2");
    glUniform1f(loc, interpolatedParameters[3]);
    loc = glGetUniformLocation(programID, "slider3");
    glUniform1f(loc, interpolatedParameters[4]);
    loc = glGetUniformLocation(programID, "slider4");
    glUniform1f(loc, interpolatedParameters[5]);
    loc = glGetUniformLocation(programID, "slider5");
    glUniform1f(loc, interpolatedParameters[6]);
    loc = glGetUniformLocation(programID, "slider6");
    glUniform1f(loc, interpolatedParameters[8]);
    loc = glGetUniformLocation(programID, "slider7");
    glUniform1f(loc, interpolatedParameters[9]);
    loc = glGetUniformLocation(programID, "slider8");
    glUniform1f(loc, interpolatedParameters[12]);
    loc = glGetUniformLocation(programID, "slider9");
    glUniform1f(loc, interpolatedParameters[13]);
#endif

    // Set texture identifiers
    GLint texture_location;
    texture_location = glGetUniformLocation(programID, "Noise3DTexture");
    glUniform1i(texture_location, 0);
    texture_location = glGetUniformLocation(programID, "DepthSensorTexture");
    glUniform1i(texture_location, 1);
    texture_location = glGetUniformLocation(programID, "BGTexture");
    glUniform1i(texture_location, 2);

    // render to larger offscreen texture
    glActiveTexture(GL_TEXTURE2);
    textureManager.getTextureID("hermaniak.tga", &textureID, errorText);
    glBindTexture(GL_TEXTURE_2D, textureID);
    glActiveTexture(GL_TEXTURE1);
    //textureManager.getTextureID(TM_DEPTH_SENSOR_NAME, &textureID, errorText);
    glBindTexture(GL_TEXTURE_2D, textureID);
    glActiveTexture(GL_TEXTURE0);
    textureManager.getTextureID(TM_NOISE3D_NAME, &textureID, errorText);
    glBindTexture(GL_TEXTURE_3D, textureID);

#if 1
    glViewport(0, 0, X_HIGHLIGHT, Y_HIGHLIGHT);
#endif

    // TODO: Here is the rendering done!
    interpolatedParameters[6] = 0.4f;

    shaderManager.getProgramID("SimpleTexture.gprg", &programID, errorText);
    glUseProgram(programID);
    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
    //glDisable(GL_BLEND);
    glDisable(GL_CULL_FACE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_DST_COLOR, GL_ZERO);

    // Texture for first pass is simply black
    textureManager.getTextureID("black.tga", &textureID, errorText);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, textureID);

    const int num_passes = 4;

    // TODO: Make the first 1 or 2 passes to the smaller backbuffer
    for (int pass = 0; pass < num_passes; pass++) {
        // Set small
        
        // In the first pass, use highlight
        if (pass < num_passes - 3) {
            glViewport(0, 0, X_HIGHLIGHT, Y_HIGHLIGHT);
        } else if (pass < num_passes - 1) {
            glViewport(0, 0, X_OFFSCREEN, Y_OFFSCREEN);
        } else {
            // Set the whole screen as viewport so that it is used in the last pass
            int xres = windowRect.right - windowRect.left;
            int yres = windowRect.bottom - windowRect.top;
            glViewport(0, 0, xres, yres);
        }

        float red = 1.0f;
        float green = 1.0f;
        float blue = 1.0f;
        glClearColor(red, green, blue, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // Draw one iteration of the IFS
        float transformation[2][3];
        for (int i = 0; i < 20; i++) {
            transformation[0][0] = 0.5f * sinf(ftime * 0.133f + 0.3f + 1.3f * i) * sinf(ftime * 0.051f + 2.8f + 4.2f * i);
            transformation[0][1] = 0.5f * sinf(ftime * 0.051f + 2.8f + 4.2f * i) * sinf(ftime * 0.087f + 4.1f + 2.3f * i);
            transformation[0][2] = 0.6f * sinf(ftime * 0.087f + 4.1f + 2.3f * i) * sinf(ftime * 0.077f + 3.2f + 6.1f * i);
            transformation[1][0] = 0.5f * sinf(ftime * 0.077f + 3.2f + 6.1f * i) * sinf(ftime * 0.028f + 7.1f + 1.9f * i);
            transformation[1][1] = 0.5f * sinf(ftime * 0.028f + 7.1f + 1.9f * i) * sinf(ftime * 0.095f + 2.3f + 0.7f * i);
            transformation[1][2] = 0.6f * sinf(ftime * 0.095f + 2.3f + 0.7f * i) * sinf(ftime * 0.133f + 0.3f + 1.3f * i);
            DrawQuad(transformation, 1.0f);
        }

        // Copy backbuffer to texture
        if (pass < num_passes - 3) {
            textureManager.getTextureID(TM_HIGHLIGHT_NAME, &textureID, errorText);
            glBindTexture(GL_TEXTURE_2D, textureID);
            glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, X_HIGHLIGHT, Y_HIGHLIGHT);
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, textureID);
        } else if (pass < num_passes - 1) {
            textureManager.getTextureID(TM_OFFSCREEN_NAME, &textureID, errorText);
            glBindTexture(GL_TEXTURE_2D, textureID);
            glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, X_OFFSCREEN, Y_OFFSCREEN);
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, textureID);
        }
    }

#if 0
	// Copy backbuffer to front (so far no improvement)
	int xres = windowRect.right - windowRect.left;
	int yres = windowRect.bottom - windowRect.top;
	glViewport(0, 0, xres, yres);
    shaderManager.getProgramID("SimpleTexture.gprg", &programID, errorText);
	glUseProgram(programID);
    loc = glGetUniformLocation(programID, "time");
	glUniform1f(loc, (float)(t * 0.001f));
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	glDisable(GL_BLEND);
	glBegin(GL_QUADS);
	glTexCoord2f(0.0f, 0.0f);
	glVertex2f(-1.0f, -1.0f);
	glTexCoord2f(1.0f, 0.0f);
	glVertex2f(1.0f, -1.0f);
	glTexCoord2f(1.0f, 1.0f);
	glVertex2f(1.0f, 1.0f);
	glTexCoord2f(0.0f, 1.0f);
	glVertex2f(-1.0f, 1.0f);
	glEnd();
#endif
}
Пример #16
0
void CPathEstimator::Draw(void)
{
	MoveData* md=moveinfo->GetMoveDataFromName("TANKSH2");
	if(!selectedUnits.selectedUnits.empty() && (*selectedUnits.selectedUnits.begin())->unitDef->movedata)
		md=(*selectedUnits.selectedUnits.begin())->unitDef->movedata;

	glDisable(GL_TEXTURE_2D);
	glColor3f(1,1,0);
	float blue=BLOCK_SIZE==32?1:0;
/*	glBegin(GL_LINES);
	for(int z = 0; z < nbrOfBlocksZ; z++) {
		for(int x = 0; x < nbrOfBlocksX; x++) {
			int blocknr = z * nbrOfBlocksX + x;
			float3 p1;
			p1.x=(blockState[blocknr].sqrCenter[md->pathType].x)*8;
			p1.z=(blockState[blocknr].sqrCenter[md->pathType].y)*8;
			p1.y=ground->GetHeight(p1.x,p1.z)+10;

			glColor3f(1,1,blue);
			glVertexf3(p1);
			glVertexf3(p1-UpVector*10);
			for(int dir = 0; dir < PATH_DIRECTION_VERTICES; dir++){
				int obx = x + directionVector[dir].x;
				int obz = z + directionVector[dir].y;

				if(obx >= 0 && obz >= 0 && obx < nbrOfBlocksX && obz < nbrOfBlocksZ) {
					float3 p2;
					int obblocknr = obz * nbrOfBlocksX + obx;

					p2.x=(blockState[obblocknr].sqrCenter[md->pathType].x)*8;
					p2.z=(blockState[obblocknr].sqrCenter[md->pathType].y)*8;
					p2.y=ground->GetHeight(p2.x,p2.z)+10;

					int vertexNbr = md->pathType * nbrOfBlocks * PATH_DIRECTION_VERTICES + blocknr * PATH_DIRECTION_VERTICES + directionVertex[dir];
					float cost=vertex[vertexNbr];

					glColor3f(1/(sqrt(cost/BLOCK_SIZE)),1/(cost/BLOCK_SIZE),blue);
					glVertexf3(p1);
					glVertexf3(p2);
				}
			}
		}

	}
	glEnd();/**/
/*	glEnable(GL_TEXTURE_2D);
	for(int z = 0; z < nbrOfBlocksZ; z++) {
		for(int x = 0; x < nbrOfBlocksX; x++) {
			int blocknr = z * nbrOfBlocksX + x;
			float3 p1;
			p1.x=(blockState[blocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
			p1.z=(blockState[blocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
			p1.y=ground->GetHeight(p1.x,p1.z)+10;

			glColor3f(1,1,blue);
			for(int dir = 0; dir < PATH_DIRECTION_VERTICES; dir++){
				int obx = x + directionVector[dir].x;
				int obz = z + directionVector[dir].y;

				if(obx >= 0 && obz >= 0 && obx < nbrOfBlocksX && obz < nbrOfBlocksZ) {
					float3 p2;
					int obblocknr = obz * nbrOfBlocksX + obx;

					p2.x=(blockState[obblocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
					p2.z=(blockState[obblocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
					p2.y=ground->GetHeight(p2.x,p2.z)+10;

					int vertexNbr = md->pathType * nbrOfBlocks * PATH_DIRECTION_VERTICES + blocknr * PATH_DIRECTION_VERTICES + directionVertex[dir];
					float cost=vertex[vertexNbr];

					glColor3f(1,1/(cost/BLOCK_SIZE),blue);

					p2=(p1+p2)/2;
					if(camera->pos.distance(p2)<500){
						glPushMatrix();
						glTranslatef3(p2);
						glScalef(5,5,5);
						font->glWorldPrint("%.0f",cost);
						glPopMatrix();
					}
				}
			}
		}
	}
*/
	if(BLOCK_SIZE==8)
		glColor3f(0.2,0.7,0.2);
	else
		glColor3f(0.2,0.2,0.7);
	glDisable(GL_TEXTURE_2D);
	glBegin(GL_LINES);
	for(OpenBlock*  ob=openBlockBuffer;ob!=openBlockBufferPointer;++ob){
		int blocknr = ob->blocknr;
		float3 p1;
		p1.x=(blockState[blocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
		p1.z=(blockState[blocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
		p1.y=ground->GetHeight(p1.x,p1.z)+15;

		float3 p2;
		int obx=blockState[ob->blocknr].parentBlock.x;
		int obz=blockState[ob->blocknr].parentBlock.y;
		int obblocknr =  obz * nbrOfBlocksX + obx;

		if(obblocknr>=0){
			p2.x=(blockState[obblocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
			p2.z=(blockState[obblocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
			p2.y=ground->GetHeight(p2.x,p2.z)+15;

			glVertexf3(p1);
			glVertexf3(p2);
		}
	}
	glEnd();
/*	glEnable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glColor4f(1,0,blue,0.7);
	glAlphaFunc(GL_GREATER,0.05);
	int a=0;
	for(OpenBlock*  ob=openBlockBuffer;ob!=openBlockBufferPointer;++ob){
		int blocknr = ob->blocknr;
		float3 p1;
		p1.x=(ob->block.x * BLOCK_SIZE + blockState[blocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
		p1.z=(ob->block.y * BLOCK_SIZE + blockState[blocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
		p1.y=ground->GetHeight(p1.x,p1.z)+15;

		if(camera->pos.distance(p1)<500){
			glPushMatrix();
			glTranslatef3(p1);
			glScalef(5,5,5);
			font->glWorldPrint("%.0f %.0f",ob->cost,ob->currentCost);
			glPopMatrix();
		}
		++a;
	}
	glDisable(GL_BLEND);*/
}
Пример #17
0
void CollisionDemo::displayCallback(void) {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
	glDisable(GL_LIGHTING);


   
    
   btVoronoiSimplexSolver sGjkSimplexSolver;    
    
   btGjkPairDetector convexConvex(shapePtr[0],shapePtr[1],&sGjkSimplexSolver,0); 
   btPointCollector gjkOutput; 
   btGjkPairDetector::ClosestPointInput input; 
    

    
   input.m_transformA = tr[0]; 
   input.m_transformB = tr[1]; 
    
   convexConvex.getClosestPoints(input, gjkOutput, 0); 
    
   if (gjkOutput.m_hasResult) 
   { 
      //VECCOPY(pa, gjkOutput.m_pointInWorld); 
      //VECCOPY(pb, gjkOutput.m_pointInWorld); 
      //VECADDFAC(pb, pb, gjkOutput.m_normalOnBInWorld, gjkOutput.m_distance); 
             printf("bullet: %10.10f\n", gjkOutput.m_distance); // = 0.24 => that's absolutely wrong! 
	 		btVector3 endPt = gjkOutput.m_pointInWorld +
			gjkOutput.m_normalOnBInWorld*gjkOutput.m_distance;

			 glBegin(GL_LINES);
			glColor3f(1, 0, 0);
			glVertex3d(gjkOutput.m_pointInWorld.x(), gjkOutput.m_pointInWorld.y(),gjkOutput.m_pointInWorld.z());
			glVertex3d(endPt.x(),endPt.y(),endPt.z());
			//glVertex3d(gjkOutputm_pointInWorld.x(), gjkOutputm_pointInWorld.y(),gjkOutputm_pointInWorld.z());
			//glVertex3d(gjkOutputm_pointInWorld.x(), gjkOutputm_pointInWorld.y(),gjkOutputm_pointInWorld.z());
			glEnd();
   } 

   //GL_ShapeDrawer::drawCoordSystem();

	btScalar m[16];
	int i;

//	btGjkPairDetector	convexConvex(shapePtr[0],shapePtr[1],&sGjkSimplexSolver,0);

	convexConvex.getClosestPoints(input ,gjkOutput,0);

	btVector3 worldBoundsMin(-1000,-1000,-1000);
	btVector3 worldBoundsMax(1000,1000,1000);


	for (i=0;i<numObjects;i++)
	{
		
		tr[i].getOpenGLMatrix( m );

		m_shapeDrawer.drawOpenGL(m,shapePtr[i],btVector3(1,1,1),getDebugMode(),worldBoundsMin,worldBoundsMax);


	}

	simplex.setSimplexSolver(&sGjkSimplexSolver);
	btVector3 ybuf[4],pbuf[4],qbuf[4];
	int numpoints = sGjkSimplexSolver.getSimplex(pbuf,qbuf,ybuf);
	simplex.reset();
	
	for (i=0;i<numpoints;i++)
		simplex.addVertex(ybuf[i]);

	btTransform ident;
	ident.setIdentity();
	ident.getOpenGLMatrix(m);
	m_shapeDrawer.drawOpenGL(m,&simplex,btVector3(1,1,1),getDebugMode(),worldBoundsMin,worldBoundsMax);


	btQuaternion orn;
	orn.setEuler(yaw,pitch,roll);
	//let it rotate
	//tr[0].setRotation(orn);

	pitch += 0.005f;
	yaw += 0.01f;

	glFlush();
    glutSwapBuffers();
}
Пример #18
0
static void
make_helix (logo_configuration *dc, int facetted, int wire)
{
  int wall_facets = dc->wall_facets / (facetted ? 15 : 1);
  GLfloat th;
  GLfloat max_th = M_PI * 2 * dc->turns;
  GLfloat th_inc = M_PI * 2 / wall_facets;

  GLfloat x1=0,  y1=0,  x2=0,  y2=0;
  GLfloat x1b=0, y1b=0, x2b=0, y2b=0;
  GLfloat z1=0, z2=0;
  GLfloat h1=0, h2=0;
  GLfloat h1off=0, h2off=0;
  GLfloat z_inc = dc->turn_spacing / wall_facets;

  th  = 0;
  x1  = 1;
  y1  = 0;
  x1b = 1 - dc->wall_thickness;
  y1b = 0;

  z1 = -(dc->turn_spacing * dc->turns / 2);

  h1 = (dc->wall_taper > 0 ? 0 : dc->wall_height / 2);
  h1off = (dc->wall_taper > 0 ? -dc->wall_height / 2 : 0);

  if (!dc->clockwise)
    z1 = -z1, z_inc = -z_inc, h1off = -h1off;

  /* Leading end-cap
   */
  if (!wire && h1 > 0)
    {
      GLfloat nx, ny;
      glFrontFace(GL_CCW);
      glBegin(GL_QUADS);
      nx = cos (th + M_PI/2);
      ny = sin (th + M_PI/2);
      glNormal3f(nx, ny, 0);
      glVertex3f( x1, y1,  z1 - h1 + h1off);
      glVertex3f( x1, y1,  z1 + h1 + h1off);
      glVertex3f(x1b, y1b, z1 + h1 + h1off);
      glVertex3f(x1b, y1b, z1 - h1 + h1off);
      glEnd();
    }

  while (th + th_inc <= max_th)
    {
      th += th_inc;

      x2 = cos (th);
      y2 = sin (th);
      z2 = z1 + z_inc;
      x2b = x2 * (1 - dc->wall_thickness);
      y2b = y2 * (1 - dc->wall_thickness);

      h2 = h1;
      h2off = h1off;

      if (dc->wall_taper > 0)
        {
          h2off = 0;
          if (th < dc->wall_taper)
            {
              h2 = dc->wall_height/2 * cos (M_PI / 2
                                            * (1 - (th / dc->wall_taper)));
              if (dc->clockwise)
                h2off = h2 - dc->wall_height/2;
              else
                h2off = dc->wall_height/2 - h2;
            }
          else if (th >= max_th - dc->wall_taper)
            {
              if (th + th_inc > max_th) /* edge case: always come to a point */
                h2 = 0;
              else
                h2 = dc->wall_height/2 * cos (M_PI / 2
                                              * (1 - ((max_th - th)
                                                      / dc->wall_taper)));
              if (dc->clockwise)
                h2off = dc->wall_height/2 - h2;
              else
                h2off = h2 - dc->wall_height/2;
            }
        }

      /* outer face
       */
      glFrontFace(GL_CW);
      glBegin(wire ? GL_LINES : GL_QUADS);
      glNormal3f(x1, y1, 0);
      glVertex3f(x1, y1, z1 - h1 + h1off);
      glVertex3f(x1, y1, z1 + h1 + h1off);
      glNormal3f(x2, y2, 0);
      glVertex3f(x2, y2, z2 + h2 + h2off);
      glVertex3f(x2, y2, z2 - h2 + h2off);
      glEnd();

      /* inner face
       */
      glFrontFace(GL_CCW);
      glBegin(wire ? GL_LINES : GL_QUADS);
      glNormal3f(-x1b, -y1b, 0);
      glVertex3f( x1b,  y1b, z1 - h1 + h1off);
      glVertex3f( x1b,  y1b, z1 + h1 + h1off);
      glNormal3f(-x2b, -y2b, 0);
      glVertex3f( x2b,  y2b, z2 + h2 + h2off);
      glVertex3f( x2b,  y2b, z2 - h2 + h2off);
      glEnd();

      /* top face
       */
      glFrontFace(GL_CCW);
      /* glNormal3f(0, 0, 1);*/
      do_normal (x2,   y2,  z2 + h2 + h2off,
                 x2b,  y2b, z2 + h2 + h2off,
                 x1b,  y1b, z1 + h1 + h1off);
      glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
      glVertex3f( x2,   y2,  z2 + h2 + h2off);
      glVertex3f( x2b,  y2b, z2 + h2 + h2off);
      glVertex3f( x1b,  y1b, z1 + h1 + h1off);
      glVertex3f( x1,   y1,  z1 + h1 + h1off);

      glEnd();

      /* bottom face
       */
      glFrontFace(GL_CCW);
      do_normal ( x1,   y1,  z1 - h1 + h1off,
                  x1b,  y1b, z1 - h1 + h1off,
                  x2b,  y2b, z2 - h2 + h2off);
      glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
      glNormal3f(0, 0, -1);
      glVertex3f( x1,   y1,  z1 - h1 + h1off);
      glVertex3f( x1b,  y1b, z1 - h1 + h1off);
      glVertex3f( x2b,  y2b, z2 - h2 + h2off);
      glVertex3f( x2,   y2,  z2 - h2 + h2off);
      glEnd();

      x1 = x2;
      y1 = y2;
      x1b = x2b;
      y1b = y2b;
      z1 += z_inc;
      h1 = h2;
      h1off = h2off;
    }

  /* Trailing end-cap
   */
  if (!wire && h2 > 0)
    {
      GLfloat nx, ny;
      glFrontFace(GL_CW);
      glBegin(GL_QUADS);
      nx = cos (th + M_PI/2);
      ny = sin (th + M_PI/2);
      glNormal3f(nx, ny, 0);
      glVertex3f(x2,  y2,  z1 - h2 + h2off);
      glVertex3f(x2,  y2,  z1 + h2 + h2off);
      glVertex3f(x2b, y2b, z1 + h2 + h2off);
      glVertex3f(x2b, y2b, z1 - h2 + h2off);
      glEnd();
    }
}
Пример #19
0
void ofxCamMapper::gen_Pts(){
	//キャリブレーションセクション
	if (bGen_Mapping){
		if (Genframe == -1){//Initialize
			phase_x = 0;
			phase_y = 1;
			calib_next = false;
			
			currentPts = (*out_pts).size();
			
			phase = phase_x;
			head = 0;
			size = BUFFER_WIDTH;
			
			color_score = 0;
			Genframe = 0;
			calib_waiter = ofGetElapsedTimeMillis();
		}
		
		/*-------------------動的なキャリブレーションの処理------------*/
		//----------------パターンの描画
		Buffer_out.begin();
		glClearColor(0, 0, 0, 1.0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		ofSetRectMode(OF_RECTMODE_CORNER);
		ofSetColor(pattern_color);
		if (phase == phase_x){
			ofRect(head+size/2*calib_next, 0, size/2, BUFFER_HEIGHT);
		}
		if (phase == phase_y){
			ofRect(0,head+size/2*calib_next,BUFFER_WIDTH,size/2);
		}
		Buffer_out.end();
		
		
		//--------------カラーの比較・評価
		if ((ofGetElapsedTimeMillis() - calib_waiter) > calib_lateMs){
			trackingColor = getProjectionColor(cam_pts[currentPts]);
			if ((abs(trackingColor.r - sampleColor.r) < 60)&&
				(abs(trackingColor.g - sampleColor.g) < 60)&&
				(abs(trackingColor.b - sampleColor.b) < 60)){
				color_score++;
			}
			Genframe++;
		}
		
		//--------------比較を終了・データまとめて評価開始
		static int endChecker = 0,endCounter;
		if ((ofGetElapsedTimeMillis() - calib_waiter) > calib_waitMs+calib_lateMs){
			if ((color_score / (float)Genframe) > 0.3){
				if (!calib_next){
					size = MAX(1,size/2);
				}else{
					head = head+size/2;
					size = MAX(1,size/2);
					calib_next = false;
				}
			}else{
				if (!calib_next){
					calib_next = true;
				}else{
					head += size/3;
					calib_next = false;
				}
			}
			if (size != endChecker){
				endCounter = 0;
			}else{
				endCounter++;
			}
			endChecker = size;
			if (endCounter > 5){
				endCounter = 0;
				endChecker = 0;
				if (phase == phase_x){
					phase = phase_y;
					answer.x = head+size;
					head = 0;
					size = BUFFER_HEIGHT;
				}else{
					answer.y = head+size/2;
					currentPts++;
					
					(*out_pts).push_back(answer);
					src_editor.sync_Pts(-1);
					
					if (currentPts >= cam_pts.size()){
						bGen_Mapping = false;
					}
					phase = phase_x;
					head = 0;
					size = BUFFER_WIDTH;
					color_score = 0;
					Genframe = 0;
					calib_waiter = ofGetElapsedTimeMillis();
				}
			}
			Genframe = 0;
			color_score = 0;
			calib_waiter = ofGetElapsedTimeMillis();
		}
		
	}else{
		Buffer_out.begin();
		glClearColor(0, 0, 0, 1.0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		ofSetColor(pattern_color);
		if ((*out_pts).size() == 0)
		{
			ofRect(0, 0, BUFFER_WIDTH, BUFFER_HEIGHT);
			Buffer_out.end();
		}else {
			
			ofSetHexColor(0xFFFFFF);
			Buffer_src.getTextureReference().bind();
			for (int i = 0;i < src_editor.tris.size();i++){
				glBegin(GL_TRIANGLE_STRIP);
				for (int j = 0;j < 3;j++){
					glTexCoord2f(src_editor.pts[src_editor.tris[i].idx[j]].x, 
								 src_editor.pts[src_editor.tris[i].idx[j]].y);
					glVertex2f(vert_child.pts[vert_child.tris[i].idx[j]].x,
							   vert_child.pts[vert_child.tris[i].idx[j]].y);
				}
				glEnd();
			}
			Buffer_src.getTextureReference().unbind();
			Buffer_out.end();
			
			if (inverse_affine){
				for (int i = 0;i < src_editor.rects.size();i++){
					pers_rectangle pr;
					pers_rectangle_invert pri;
					
					for (int j = 0;j < 4;j++){
						pr.srcp[j]  = src_editor.pts[src_editor.rects[i].idx[j]] / ofPoint(BUFFER_WIDTH,BUFFER_HEIGHT);
						pr.pts[j]   = vert_child.pts[src_editor.rects[i].idx[j]] / ofPoint(BUFFER_WIDTH,BUFFER_HEIGHT);
						pri.srcp[j]  = src_editor.pts[src_editor.rects[i].idx[j]] / ofPoint(BUFFER_WIDTH,BUFFER_HEIGHT);
						pri.pts[j]   = src_editor.pts[src_editor.rects[i].idx[j]] / ofPoint(BUFFER_WIDTH,BUFFER_HEIGHT);
					}
					pri.pts[0] = ofPoint(0,0);
					pri.pts[1] = ofPoint(1,0);
					pri.pts[2] = ofPoint(1,1);
					pri.pts[3] = ofPoint(0,1);
					
					pr.srcp[0] = ofPoint(0,0);
					pr.srcp[1] = ofPoint(1,0);
					pr.srcp[2] = ofPoint(1,1);
					pr.srcp[3] = ofPoint(0,1);
					
					//逆行列の計算する
					Buffer_invert.begin();
					ofClear(0, 0, 0);
					Buffer_src.getTextureReference().bind();
					glPushMatrix();
					pri.setMatrix(BUFFER_WIDTH, BUFFER_HEIGHT);
					glBegin(GL_TRIANGLE_STRIP);
					
					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[0]].x,
								 src_editor.pts[src_editor.rects[i].idx[0]].y);
					glVertex2f(src_editor.pts[src_editor.rects[i].idx[0]].x,
							   src_editor.pts[src_editor.rects[i].idx[0]].y);

					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[1]].x,
								 src_editor.pts[src_editor.rects[i].idx[1]].y);
					glVertex2f(src_editor.pts[src_editor.rects[i].idx[1]].x,
							   src_editor.pts[src_editor.rects[i].idx[1]].y);

					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[3]].x,
								 src_editor.pts[src_editor.rects[i].idx[3]].y);
					glVertex2f(src_editor.pts[src_editor.rects[i].idx[3]].x,
							   src_editor.pts[src_editor.rects[i].idx[3]].y);

					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[2]].x,
								 src_editor.pts[src_editor.rects[i].idx[2]].y);
					glVertex2f(src_editor.pts[src_editor.rects[i].idx[2]].x,
							   src_editor.pts[src_editor.rects[i].idx[2]].y);

					glEnd();
					
					glPopMatrix();
					Buffer_src.getTextureReference().unbind();
					Buffer_invert.end();
					
					//インバースから引っ張ってくる
					Buffer_out.begin();
					Buffer_invert.getTextureReference().bind();
					glPushMatrix();
					pr.setMatrix(BUFFER_WIDTH, BUFFER_HEIGHT);
					glBegin(GL_TRIANGLE_STRIP);
					
					glTexCoord2f(0,0);
					glVertex2f  (0,0);
					
					glTexCoord2f(BUFFER_WIDTH,0);
					glVertex2f  (BUFFER_WIDTH,0);
					
					glTexCoord2f(0,BUFFER_HEIGHT);
					glVertex2f  (0,BUFFER_HEIGHT);

					glTexCoord2f(BUFFER_WIDTH,BUFFER_HEIGHT);
					glVertex2f  (BUFFER_WIDTH,BUFFER_HEIGHT);
					
					glEnd();
					glPopMatrix();
					Buffer_invert.getTextureReference().unbind();
					Buffer_out.end();
				}	
			}else{
				for (int i = 0;i < src_editor.rects.size();i++){
					Buffer_out.begin();
					Buffer_src.getTextureReference().bind();
					pers_rectangle pr;
					for (int j = 0;j < 4;j++){
						pr.srcp[j] = src_editor.pts[src_editor.rects[i].idx[j]] / ofPoint(BUFFER_WIDTH,BUFFER_HEIGHT);
						pr.pts[j]  = vert_child.pts[src_editor.rects[i].idx[j]] / ofPoint(BUFFER_WIDTH,BUFFER_HEIGHT);
					}
					glPushMatrix();
					pr.setMatrix(BUFFER_WIDTH, BUFFER_HEIGHT);
					glBegin(GL_QUADS);
					
					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[0]].x,
								 src_editor.pts[src_editor.rects[i].idx[0]].y);
					glVertex2f(0,0);
					
					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[1]].x,
								 src_editor.pts[src_editor.rects[i].idx[1]].y);
					glVertex2f(BUFFER_WIDTH,0);
					
					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[2]].x,
								 src_editor.pts[src_editor.rects[i].idx[2]].y);
					glVertex2f(BUFFER_WIDTH,BUFFER_HEIGHT);
					
					glTexCoord2f(src_editor.pts[src_editor.rects[i].idx[3]].x,
								 src_editor.pts[src_editor.rects[i].idx[3]].y);
					glVertex2f(0,BUFFER_HEIGHT);
					
					glEnd();
					glPopMatrix();
					Buffer_src.getTextureReference().unbind();
					Buffer_out.end();
				}
			}
			Buffer_out.begin();
//			ofSetHexColor(0x0);
            ofDisableAlphaBlending();
            glColor4f(0.0, 0.0, 0.0, 0.0);
			for (int i = 0;i < mask.rects.size();i++){
				glBegin(GL_TRIANGLE_STRIP);
				glVertex2f(mask.pts[mask.rects[i].idx[0]].x,
						   mask.pts[mask.rects[i].idx[0]].y);
				glVertex2f(mask.pts[mask.rects[i].idx[1]].x,
						   mask.pts[mask.rects[i].idx[1]].y);
				glVertex2f(mask.pts[mask.rects[i].idx[3]].x,
						   mask.pts[mask.rects[i].idx[3]].y);
				glVertex2f(mask.pts[mask.rects[i].idx[2]].x,
						   mask.pts[mask.rects[i].idx[2]].y);
				glEnd();
			}
			for (int i = 0;i < mask.tris.size();i++){
				glBegin(GL_TRIANGLE_STRIP);
				glVertex2f(mask.pts[mask.tris[i].idx[0]].x,
						   mask.pts[mask.tris[i].idx[0]].y);
				glVertex2f(mask.pts[mask.tris[i].idx[1]].x,
						   mask.pts[mask.tris[i].idx[1]].y);
				glVertex2f(mask.pts[mask.tris[i].idx[2]].x,
						   mask.pts[mask.tris[i].idx[2]].y);
				glEnd();
			}
			Buffer_out.end();
            ofEnableAlphaBlending();
		}
		ofSetHexColor(0xFFFFFF);
//		for (int i = 0;i < (*out_pts).size();i++){
//			ofNoFill();
//			ofSetHexColor(0xFF0000);
//			ofCircle((*out_pts)[i].x, (*out_pts)[i].y, 14);
//			ofSetHexColor(0xFFFFFF);
//			ofCircle((*out_pts)[i].x, (*out_pts)[i].y, 7);
//			ofLine((*out_pts)[i].x-5, (*out_pts)[i].y, (*out_pts)[i].x+5, (*out_pts)[i].y);
//			ofLine((*out_pts)[i].x, (*out_pts)[i].y-5, (*out_pts)[i].x, (*out_pts)[i].y+5);
//			ofFill();
//		}
		Buffer_out.begin();
		if (drawChild) {
			vert_child.buffer.draw(0, 0,BUFFER_WIDTH,BUFFER_HEIGHT);
            ofEnableBlendMode(OF_BLENDMODE_ALPHA);
			ofSetHexColor(0x0);
			for (int i = 0;i < mask.rects.size();i++){
				glBegin(GL_TRIANGLE_STRIP);
				glVertex2f(mask.pts[mask.rects[i].idx[0]].x,
						   mask.pts[mask.rects[i].idx[0]].y);
				glVertex2f(mask.pts[mask.rects[i].idx[1]].x,
						   mask.pts[mask.rects[i].idx[1]].y);
				glVertex2f(mask.pts[mask.rects[i].idx[3]].x,
						   mask.pts[mask.rects[i].idx[3]].y);
				glVertex2f(mask.pts[mask.rects[i].idx[2]].x,
						   mask.pts[mask.rects[i].idx[2]].y);
				glEnd();
			}
			for (int i = 0;i < mask.tris.size();i++){
				glBegin(GL_TRIANGLE_STRIP);
				glVertex2f(mask.pts[mask.tris[i].idx[0]].x,
						   mask.pts[mask.tris[i].idx[0]].y);
				glVertex2f(mask.pts[mask.tris[i].idx[1]].x,
						   mask.pts[mask.tris[i].idx[1]].y);
				glVertex2f(mask.pts[mask.tris[i].idx[2]].x,
						   mask.pts[mask.tris[i].idx[2]].y);
				glEnd();
			}
		}
		Buffer_out.end();
	}
}
Пример #20
0
static void
make_gasket (logo_configuration *dc, int wire)
{
  int i;
  int points_size;
  int npoints = 0;
  int nctrls = 0;
  int res = 360/8;
  GLfloat d2r = M_PI / 180;

  GLfloat thick2 = (dc->gasket_thickness / dc->gasket_size) / 2;

  GLfloat *pointsx0, *pointsy0, *pointsx1, *pointsy1, *normals;

  GLfloat r0  = 0.780;  /* 395 */
  GLfloat r1a = 0.855;                /* top of wall below upper left hole */
  GLfloat r1b = 0.890;                /* center of upper left hole */
  GLfloat r1c = 0.922;                /* bottom of wall above hole */
  GLfloat r1  = 0.928;  /* 471 */
  GLfloat r2  = 0.966;  /* 490 */
  GLfloat r3  = 0.984;  /* 499 */
  GLfloat r4  = 1.000;  /* 507 */
  GLfloat r5  = 1.090;  /* 553 */

  GLfloat ctrl_r[100], ctrl_th[100];

  glPushMatrix();

# define POINT(r,th) \
    ctrl_r [nctrls] = r, \
    ctrl_th[nctrls] = (th * d2r), \
    nctrls++

  POINT (0.829, 0);      /* top indentation, right half */
  POINT (0.831, 0.85);
  POINT (0.835, 1.81);
  POINT (0.841, 2.65);
  POINT (0.851, 3.30);
  POINT (0.862, 3.81);
  POINT (0.872, 3.95);

  POINT (r4,    4.0);   /* moving clockwise... */
  POINT (r4,   48.2);
  POINT (r1,   48.2);
  POINT (r1,   54.2);
  POINT (r2,   55.8);
  POINT (r2,   73.2);
  POINT (r1,   74.8);
  POINT (r1,  101.2);
  POINT (r3,  103.4);
  POINT (r3,  132.0);
  POINT (r1,  133.4);

  POINT (r1,  180.7);
  POINT (r2,  183.6);
  POINT (r2,  209.8);
  POINT (r1,  211.0);
  POINT (r1,  221.8);
  POINT (r5,  221.8);
  POINT (r5,  223.2);
  POINT (r4,  223.2);

  POINT (r4,  316.8);      /* upper left indentation */
  POINT (0.990, 326.87);
  POINT (0.880, 327.21);
  POINT (0.872, 327.45);
  POINT (0.869, 327.80);
  POINT (0.867, 328.10);

  POINT (0.867, 328.85);
  POINT (0.869, 329.15);
  POINT (0.872, 329.50);
  POINT (0.880, 329.74);
  POINT (0.990, 330.08);

  POINT (r4,  339.0);
  if (! wire)
    {
      POINT (r1a, 339.0);      /* cut-out disc */
      POINT (r1a, 343.0);
    }
  POINT (r4,  343.0);
  POINT (r4,  356.0);

  POINT (0.872, 356.05);   /* top indentation, left half */
  POINT (0.862, 356.19);
  POINT (0.851, 356.70);
  POINT (0.841, 357.35);
  POINT (0.835, 358.19);
  POINT (0.831, 359.15);
  POINT (0.829, 360);
# undef POINT

  points_size = res + (nctrls * 2);
  pointsx0 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
  pointsy0 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
  pointsx1 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
  pointsy1 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
  normals  = (GLfloat *) malloc (points_size * sizeof(GLfloat) * 2);

  npoints = 0;
  for (i = 1; i < nctrls; i++)
    {
      GLfloat from_r  = ctrl_r [i-1];
      GLfloat from_th = ctrl_th[i-1];
      GLfloat to_r    = ctrl_r [i];
      GLfloat to_th   = ctrl_th[i];

      GLfloat step = 2*M_PI / res;
      int nsteps = 1 + ((to_th - from_th) / step);
      int j;

      for (j = 0; j < nsteps + (i == nctrls-1); j++)
        {
          GLfloat r  = from_r  + (j * (to_r  - from_r)  / nsteps);
          GLfloat th = from_th + (j * (to_th - from_th) / nsteps);

          GLfloat cth = cos(th) * dc->gasket_size;
          GLfloat sth = sin(th) * dc->gasket_size;

          pointsx0[npoints] = r0 * cth;  /* inner ring */
          pointsy0[npoints] = r0 * sth;
          pointsx1[npoints] = r  * cth;  /* outer ring */
          pointsy1[npoints] = r  * sth;
          npoints++;

          if (npoints >= points_size) abort();
        }
    }

  /* normals for the outer ring */
  for (i = 1; i < npoints; i++)
    {
      XYZ a, b, c, n;
      a.x = pointsx1[i-1];
      a.y = pointsy1[i-1];
      a.z = 0;
      b.x = pointsx1[i];
      b.y = pointsy1[i];
      b.z = 0;
      c = b;
      c.z = 1;
      n = calc_normal (a, b, c);
      normals[(i-1)*2  ] = n.x;
      normals[(i-1)*2+1] = n.y;
    }

  glRotatef(-90, 0, 1, 0);
  glRotatef(180, 0, 0, 1);

  if (wire)
    {
      GLfloat z;
      for (z = -thick2; z <= thick2; z += thick2*2)
        {
# if 1
          /* inside edge */
          glBegin (GL_LINE_LOOP);
          for (i = 0; i < npoints; i++)
            glVertex3f (pointsx0[i], pointsy0[i], z);
          glEnd();

          /* outside edge */
          glBegin (GL_LINE_LOOP);
          for (i = 0; i < npoints; i++)
            glVertex3f (pointsx1[i], pointsy1[i], z);
          glEnd();
# else
          for (i = 1; i < npoints; i++)
            {
              glBegin (GL_LINE_STRIP);
              glVertex3f (pointsx0[i-1], pointsy0[i-1], z);
              glVertex3f (pointsx0[i  ], pointsy0[i  ], z);
              glVertex3f (pointsx1[i  ], pointsy1[i  ], z);
              glVertex3f (pointsx1[i-1], pointsy1[i-1], z);
              glEnd();
            }
# endif
        }
#if 1
      glBegin (GL_LINES);
      for (i = 0; i < npoints; i++)
        {
          /* inside rim */
          glVertex3f (pointsx0[i], pointsy0[i], -thick2);
          glVertex3f (pointsx0[i], pointsy0[i],  thick2);
          /* outside rim */
          glVertex3f (pointsx1[i], pointsy1[i], -thick2);
          glVertex3f (pointsx1[i], pointsy1[i],  thick2);
        }
      glEnd();
#endif
    }
  else
    {
      /* top */
      glFrontFace(GL_CW);
      glNormal3f(0, 0, -1);
      glBegin (GL_QUAD_STRIP);
      for (i = 0; i < npoints; i++)
        {
          glVertex3f (pointsx0[i], pointsy0[i], -thick2);
          glVertex3f (pointsx1[i], pointsy1[i], -thick2);
        }
      glEnd();

      /* bottom */
      glFrontFace(GL_CCW);
      glNormal3f(0, 0, 1);
      glBegin (GL_QUAD_STRIP);
      for (i = 0; i < npoints; i++)
        {
          glVertex3f (pointsx0[i], pointsy0[i], thick2);
          glVertex3f (pointsx1[i], pointsy1[i], thick2);
        }
      glEnd();

      /* inside edge */
      glFrontFace(GL_CW);
      glBegin (GL_QUAD_STRIP);
      for (i = 0; i < npoints; i++)
        {
          glNormal3f (-pointsx0[i], -pointsy0[i],  0);
          glVertex3f ( pointsx0[i],  pointsy0[i],  thick2);
          glVertex3f ( pointsx0[i],  pointsy0[i], -thick2);
        }
      glEnd();

      /* outside edge */
      glFrontFace(GL_CCW);
      glBegin (GL_QUADS);
      {
        for (i = 0; i < npoints-1; i++)
          {
            int ia = (i == 0 ? npoints-2 : i-1);
            int iz = (i == npoints-2 ? 0 : i+1);
            GLfloat  x = pointsx1[i];
            GLfloat  y = pointsy1[i];
            GLfloat xz = pointsx1[iz];
            GLfloat yz = pointsy1[iz];

            GLfloat nxa = normals[ia*2];   /* normal of [i-1 - i] face */
            GLfloat nya = normals[ia*2+1];
            GLfloat nx  = normals[i*2];    /* normal of [i - i+1] face */
            GLfloat ny  = normals[i*2+1];
            GLfloat nxz = normals[iz*2];    /* normal of [i+1 - i+2] face */
            GLfloat nyz = normals[iz*2+1];

            GLfloat anglea = vector_angle (nx, ny, 0, nxa, nya, 0);
            GLfloat anglez = vector_angle (nx, ny, 0, nxz, nyz, 0);
            GLfloat pointy = 0.005;

            if (anglea > pointy)
              {
                glNormal3f (nx, ny, 0);
                glVertex3f (x,  y,   thick2);
                glVertex3f (x,  y,  -thick2);
              }
            else
              {
                glNormal3f ((nxa + nx) / 2, (nya + ny) / 2, 0);
                glVertex3f (x,  y,   thick2);
                glVertex3f (x,  y,  -thick2);
              }

            if (anglez > pointy)
              {
                glNormal3f (nx, ny, 0);
                glVertex3f (xz, yz, -thick2);
                glVertex3f (xz, yz,  thick2);
              }
            else
              {
                glNormal3f ((nx + nxz) / 2, (ny + nyz) / 2, 0);
                glVertex3f (xz, yz, -thick2);
                glVertex3f (xz, yz,  thick2);
              }
          }
      }
      glEnd();
    }

  /* Fill in the upper left hole...
   */
  {
    GLfloat th;
    npoints = 0;

    th = 339.0 * d2r;
    pointsx0[npoints] = r1c * cos(th) * dc->gasket_size;
    pointsy0[npoints] = r1c * sin(th) * dc->gasket_size;
    npoints++;
    pointsx0[npoints] = r4 * cos(th) * dc->gasket_size;
    pointsy0[npoints] = r4 * sin(th) * dc->gasket_size;
    npoints++;

    th = 343.0 * d2r;
    pointsx0[npoints] = r1c * cos(th) * dc->gasket_size;
    pointsy0[npoints] = r1c * sin(th) * dc->gasket_size;
    npoints++;
    pointsx0[npoints] = r4 * cos(th) * dc->gasket_size;
    pointsy0[npoints] = r4 * sin(th) * dc->gasket_size;
    npoints++;

    if (! wire)
      {
        /* front wall */
        glNormal3f (0, 0, -1);
        glFrontFace(GL_CW);
        glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
        glVertex3f (pointsx0[0], pointsy0[0], -thick2);
        glVertex3f (pointsx0[1], pointsy0[1], -thick2);
        glVertex3f (pointsx0[3], pointsy0[3], -thick2);
        glVertex3f (pointsx0[2], pointsy0[2], -thick2);
        glEnd();

        /* back wall */
        glNormal3f (0, 0, 1);
        glFrontFace(GL_CCW);
        glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
        glVertex3f (pointsx0[0], pointsy0[0],  thick2);
        glVertex3f (pointsx0[1], pointsy0[1],  thick2);
        glVertex3f (pointsx0[3], pointsy0[3],  thick2);
        glVertex3f (pointsx0[2], pointsy0[2],  thick2);
        glEnd();
      }

    /* top wall */
    glFrontFace(GL_CW);
    glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
    glNormal3f (pointsx0[1], pointsy0[1], 0);
    glVertex3f (pointsx0[1], pointsy0[1],  thick2);
    glNormal3f (pointsx0[3], pointsy0[3], 0);
    glVertex3f (pointsx0[3], pointsy0[3],  thick2);
    glVertex3f (pointsx0[3], pointsy0[3], -thick2);
    glNormal3f (pointsx0[1], pointsy0[1], 0);
    glVertex3f (pointsx0[1], pointsy0[1], -thick2);
    glEnd();


    /* Now make a donut.
     */
    {
      int nsteps = 12;
      GLfloat r0 = 0.026;
      GLfloat r1 = 0.060;
      GLfloat th, cth, sth;

      glPushMatrix ();

      th = ((339.0 + 343.0) / 2) * d2r;
      
      glTranslatef (r1b * cos(th) * dc->gasket_size,
                    r1b * sin(th) * dc->gasket_size,
                    0);

      npoints = 0;
      for (i = 0; i < nsteps; i++)
        {
          th = 2 * M_PI * i / nsteps;
          cth = cos (th) * dc->gasket_size;
          sth = sin (th) * dc->gasket_size;
          pointsx0[npoints] = r0 * cth;
          pointsy0[npoints] = r0 * sth;
          pointsx1[npoints] = r1 * cth;
          pointsy1[npoints] = r1 * sth;
          npoints++;
        }

      pointsx0[npoints] = pointsx0[0];
      pointsy0[npoints] = pointsy0[0];
      pointsx1[npoints] = pointsx1[0];
      pointsy1[npoints] = pointsy1[0];
      npoints++;

      if (wire)
        {
          glBegin (GL_LINE_LOOP);
          for (i = 0; i < npoints; i++)
            glVertex3f (pointsx0[i], pointsy0[i], -thick2);
          glEnd();
          glBegin (GL_LINE_LOOP);
          for (i = 0; i < npoints; i++)
            glVertex3f (pointsx0[i], pointsy0[i],  thick2);
          glEnd();
# if 0
          glBegin (GL_LINE_LOOP);
          for (i = 0; i < npoints; i++)
            glVertex3f (pointsx1[i], pointsy1[i], -thick2);
          glEnd();
          glBegin (GL_LINE_LOOP);
          for (i = 0; i < npoints; i++)
            glVertex3f (pointsx1[i], pointsy1[i],  thick2);
          glEnd();
# endif
        }
      else
        {
          /* top */
          glFrontFace(GL_CW);
          glNormal3f(0, 0, -1);
          glBegin (GL_QUAD_STRIP);
          for (i = 0; i < npoints; i++)
            {
              glVertex3f (pointsx0[i], pointsy0[i], -thick2);
              glVertex3f (pointsx1[i], pointsy1[i], -thick2);
            }
          glEnd();

          /* bottom */
          glFrontFace(GL_CCW);
          glNormal3f(0, 0, 1);
          glBegin (GL_QUAD_STRIP);
          for (i = 0; i < npoints; i++)
            {
              glVertex3f (pointsx0[i], pointsy0[i],  thick2);
              glVertex3f (pointsx1[i], pointsy1[i],  thick2);
            }
          glEnd();
        }

      /* inside edge */
      glFrontFace(GL_CW);
      glBegin (wire ? GL_LINES : GL_QUAD_STRIP);
      for (i = 0; i < npoints; i++)
        {
          glNormal3f (-pointsx0[i], -pointsy0[i],  0);
          glVertex3f ( pointsx0[i],  pointsy0[i],  thick2);
          glVertex3f ( pointsx0[i],  pointsy0[i], -thick2);
        }
      glEnd();

      glPopMatrix();
    }
  }


  /* Attach the bottom-right dingus...
   */
  {
    GLfloat w = 0.04;
    GLfloat h = 0.17;
    GLfloat th;

    glRotatef (50, 0, 0, 1);
    glScalef (dc->gasket_size, dc->gasket_size, 1);
    glTranslatef (0, (r0+r1)/2, 0);

    /* buried box */
    if (! wire)
      {
        glFrontFace(GL_CCW);
        glBegin (wire ? GL_LINE_STRIP : GL_QUADS);
        glNormal3f (0, 0, -1);
        glVertex3f (-w/2, -h/2, -thick2); glVertex3f (-w/2,  h/2, -thick2);
        glVertex3f ( w/2,  h/2, -thick2); glVertex3f ( w/2, -h/2, -thick2);
        glNormal3f (1, 0, 0);
        glVertex3f ( w/2, -h/2, -thick2); glVertex3f ( w/2,  h/2, -thick2);
        glVertex3f ( w/2,  h/2,  thick2); glVertex3f ( w/2, -h/2,  thick2);
        glNormal3f (0, 0, 1);
        glVertex3f ( w/2, -h/2,  thick2); glVertex3f ( w/2,  h/2,  thick2);
        glVertex3f (-w/2,  h/2,  thick2); glVertex3f (-w/2, -h/2,  thick2);
        glNormal3f (-1, 0, 0);
        glVertex3f (-w/2, -h/2,  thick2); glVertex3f (-w/2,  h/2,  thick2);
        glVertex3f (-w/2,  h/2, -thick2); glVertex3f (-w/2, -h/2, -thick2);
        glEnd();
      }

    npoints = 0;
    for (th = 0; th < M_PI; th += (M_PI / 6))
      {
        pointsx0[npoints] = w/2 * cos(th);
        pointsy0[npoints] = w/2 * sin(th);
        npoints++;
      }

    /* front inside curve */
    glNormal3f (0, 0, -1);
    glFrontFace(GL_CW);
    glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
    if (! wire) glVertex3f (0, h/2, -thick2);
    for (i = 0; i < npoints; i++)
      glVertex3f (pointsx0[i], h/2 + pointsy0[i], -thick2);
    glEnd();

    /* front outside curve */
    glFrontFace(GL_CCW);
    glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
    if (! wire) glVertex3f (0, -h/2, -thick2);
    for (i = 0; i < npoints; i++)
      glVertex3f (pointsx0[i], -h/2 - pointsy0[i], -thick2);
    glEnd();

    /* back inside curve */
    glNormal3f (0, 0, 1);
    glFrontFace(GL_CCW);
    glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
    if (! wire) glVertex3f (0, h/2, thick2);
    for (i = 0; i < npoints; i++)
      glVertex3f (pointsx0[i], h/2 + pointsy0[i], thick2);
    glEnd();

    /* back outside curve */
    glFrontFace(GL_CW);
    glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
    if (! wire) glVertex3f (0, -h/2, thick2);
    for (i = 0; i < npoints; i++)
      glVertex3f (pointsx0[i], -h/2 - pointsy0[i], thick2);
    glEnd();

    /* inside curve */
    glFrontFace(GL_CCW);
    glBegin (wire ? GL_LINES : GL_QUAD_STRIP);
    for (i = 0; i < npoints; i++)
      {
        glNormal3f (pointsx0[i], pointsy0[i], 0);
        glVertex3f (pointsx0[i], h/2 + pointsy0[i],  thick2);
        glVertex3f (pointsx0[i], h/2 + pointsy0[i], -thick2);
      }
    glEnd();

    /* outside curve */
    glFrontFace(GL_CW);
    glBegin (wire ? GL_LINES : GL_QUAD_STRIP);
    for (i = 0; i < npoints; i++)
      {
        glNormal3f (pointsx0[i], -pointsy0[i], 0);
        glVertex3f (pointsx0[i], -h/2 - pointsy0[i],  thick2);
        glVertex3f (pointsx0[i], -h/2 - pointsy0[i], -thick2);
      }
    glEnd();
  }

  free (pointsx0);
  free (pointsy0);
  free (pointsx1);
  free (pointsy1);
  free (normals);

  glPopMatrix();
}
Пример #21
0
void opening() {
	if (opening_init == 0) {
		opening_init = 1;
		alSourcePlay(init_music->source);
	}
	glMatrixMode(GL_PROJECTION);          /* 投影変換行列の設定 */
	glLoadIdentity();                     /* 変換行列の初期化 */
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glOrtho(
		0,//GLdouble left,
		300,//GLdouble right,
		0,//GLdouble bottom,
		300,//GLdouble top,
		1,//GLdouble zNear, 
		-1//GLdouble zFar
		);


	init_image->changeImage();

	glColor4f(1, 1, 1, 1);
	glBegin(GL_QUADS);
	{
		glTexCoord2f(0.f, 0.f);
		glVertex2f(0, 300);
		glTexCoord2f(0.f, 1.f);
		glVertex2f(0, 0);
		glTexCoord2f(1.f, 1.f);
		glVertex2f(300, 0);
		glTexCoord2f(1.f, 0.f);
		glVertex2f(300, 300);
	}
	glEnd();

	if (o_message != NULL) {
		o_message();
	}
	else {
		glColor3f(0.7f, 0.5f, 0);
		max_font->ChangeSize(lkn::TYPE_MAX);
		max_font->DrawStringW(10, 160, L"はじめの出会い");
		font->ChangeSize(lkn::TYPE_NORMAL);
		glColor3f(1, 0, 0);
		font->DrawStringW(100, 110, L"〜ファームを救え!〜");
	}

	glDisable(GL_TEXTURE_2D);

    font->ChangeSize(lkn::TYPE_NORMAL);

	if (lkn::InputManager::getInstance()->keyPless(0x0d)) {

		if (o_message == NULL) {
			o_message = hajimemasite;
		}
		else if(o_message == hajimemasite) {
			o_message = kyuudakedo;
		}
		else if (o_message == kyuudakedo) {
			o_message = sokode;
		}
		else if (o_message == sokode) {
			o_message = tasukete;
		}
		else if (o_message == tasukete) {
			o_message = yorosikune;
		}
		else if (o_message == yorosikune) {
			o_message = NULL;
			alSourceStop(init_music->source);
			func = farm;
		}
	}

	glColor3f(0, 0, 0);
	min_font->ChangeSize(lkn::TYPE_MIN);
	min_font->DrawStringW(10, 285, L"      Enter:決定");

}
Пример #22
0
/**
 * Question 2
 * 
 * Dessine la voiture
 * @param p Position de la voiture
 */
void dessine_voiture(position p) {
	vecteur3d_cell cote;
	vec_prod3d(&cote,&(p->devant),&(p->dessus));
	double matrix[] = {
		p->devant.x,p->devant.y,p->devant.z,0 ,
		cote.x,cote.y,cote.z,0 , 
		p->dessus.x,p->dessus.y,p->dessus.z,0 ,
		p->centre.x,p->centre.y,p->centre.z,1
	};
	
	glPushMatrix();
	glMultMatrixd(matrix);
//   point3d_cell p1 = p->centre, p2 = p->centre, p3 = p->centre, p4 = p->centre;
//   vecteur3d_cell cote;
//   vec_prod3d(&cote,&(p->dessus),&(p->devant));
//   vecteur3d_cell opp_cote = cote;
//   vecteur3d_cell derriere = p->devant;
//   scal_prod3d(&opp_cote, -1);
//   scal_prod3d(&derriere, -1);
// 
//   translate3d(&p1, 1.0, &cote);
//   translate3d(&p2, -1.0, &cote);
//   translate3d(&p3, 0.5, &(p->dessus));
//   translate3d(&p4, 4.0, &(p->devant));
	
	
	glColor3f(0.2f,  0.8f,  0.2f); 
	glBegin(GL_TRIANGLES);
	glNormal3d(-1,0,0);
	glVertex3d(0,-1,0);
	glVertex3d(0,1,0);
	glVertex3d(0,1,0.5);
	
	glNormal3d(-1,0,0);
	glVertex3d(0,-1,0);
	glVertex3d(0,1,0.5);
	glVertex3d(0,-1,0.5);
	
	
// 	glColor3f(0.9f,  0.2f,  0.2f);
// 	
// 	glNormal3d(-1,0,0);
// 	glVertex3d(0,-0.9,0.2);
// 	glVertex3d(0,-0.8,0.4);
// 	glVertex3d(0,-0.9,0.4);
// 	
// 	glNormal3d(-1,0,0);
// 	glVertex3d(0,-0.8,0.2);
// 	glVertex3d(0,-0.8,0.4);
// 	glVertex3d(0,-0.9,0.2);
	
// 	glNormal3d(0,1,0);
	
// 	glNormal3d(0,1,0);
// 	glVertex3d(0,1,0);
// 	glNormal3d(0,0,1);
// 	glVertex3d(0,0,0.5);
// 	glNormal3d(1,0,0);
// 	glVertex3d(4,0,0);
// 	
// 	glNormal3d(0,-1,0);
// 	glVertex3d(0,-1,0);
// 	glNormal3d(1,0,0);
// 	glVertex3d(4,0,0);
// 	glNormal3d(0,0,1);
// 	glVertex3d(0,0,0.5);
	
	glEnd();
	
	glPopMatrix();
}
Пример #23
0
	//Wyrmgus start
//    void OpenGLGraphics::drawImage(const Image* image, int srcX, int srcY,
    void OpenGLGraphics::drawImage(Image* image, int srcX, int srcY,
	//Wyrmgus end
                                   int dstX, int dstY, int width,
								   //Wyrmgus start
//                                   int height)
                                   int height, int player, int skin_color, int hair_color, unsigned int transparency)
								   //Wyrmgus end
    {
        dstX += mClipStack.top().xOffset;
        dstY += mClipStack.top().yOffset;

        // The following code finds the real width and height of the texture.
        // OpenGL only supports texture sizes that are powers of two
        int realImageWidth = 1;
        int realImageHeight = 1;
        while (realImageWidth < image->getWidth())
        {
            realImageWidth *= 2;
        }
        while (realImageHeight < image->getHeight())
        {
            realImageHeight *= 2;
        }

        // Find OpenGL texture coordinates
        float texX1 = srcX / (float)realImageWidth;
        float texY1 = srcY / (float)realImageHeight;
        float texX2 = (srcX+width) / (float)realImageWidth;
        float texY2 = (srcY+height) / (float)realImageHeight;

        // Please dont look too closely at the next line, it is not pretty.
        // It uses the image data as a pointer to a GLuint
		//Wyrmgus start
//        glBindTexture(GL_TEXTURE_2D, *((GLuint *)(image->_getData())));
        glBindTexture(GL_TEXTURE_2D, *((GLuint *)(image->_getData(player, skin_color, hair_color))));
		//Wyrmgus end

        glEnable(GL_TEXTURE_2D);

        // Check if blending already is enabled
        if (!mAlpha)
        {
            glEnable(GL_BLEND);
        }

        // Draw a textured quad -- the image
        glBegin(GL_QUADS);
        glTexCoord2f(texX1, texY1);
        glVertex3i(dstX, dstY, 0);

        glTexCoord2f(texX1, texY2);
        glVertex3i(dstX, dstY + height, 0);

        glTexCoord2f(texX2, texY2);
        glVertex3i(dstX + width, dstY + height, 0);

        glTexCoord2f(texX2, texY1);
        glVertex3i(dstX + width, dstY, 0);
        glEnd();

        glDisable(GL_TEXTURE_2D);

        // Don't disable blending if the color has alpha
        if (!mAlpha)
        {
            glDisable(GL_BLEND);
        }
    }
Пример #24
0
void CMiniMap::DrawButtons()
{
	const int x = mouse->lastx;
	const int y = mouse->lasty;

	// update the showButtons state
	if (!showButtons) {
		if (mapBox.Inside(x, y) && (buttonSize > 0) && !globalRendering->dualScreenMode) {
			showButtons = true;
		} else {
			return;
		}
	}	else if (!mouseMove && !mouseResize &&
	           !mapBox.Inside(x, y) && !buttonBox.Inside(x, y)) {
		showButtons = false;
		return;
	}

	if (buttonsTexture) {
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, buttonsTexture);
		glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

		resizeBox.DrawTextureBox();
		moveBox.DrawTextureBox();
		maximizeBox.DrawTextureBox();
		minimizeBox.DrawTextureBox();

		glDisable(GL_TEXTURE_2D);
	} else {
		glColor4f(0.1f, 0.1f, 0.8f, 0.8f); resizeBox.DrawBox();   // blue
		glColor4f(0.0f, 0.8f, 0.0f, 0.8f); moveBox.DrawBox();     // green
		glColor4f(0.8f, 0.8f, 0.0f, 0.8f); maximizeBox.DrawBox(); // yellow
		glColor4f(0.8f, 0.0f, 0.0f, 0.8f); minimizeBox.DrawBox(); // red
	}

	// highlight
	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
	glColor4f(1.0f, 1.0f, 1.0f, 0.4f);
	if (mouseResize || (!mouseMove && resizeBox.Inside(x, y))) {
		if (!buttonsTexture) { glColor4f(0.3f, 0.4f, 1.0f, 0.9f); }
		resizeBox.DrawBox();
	}
	else if (mouseMove || (!mouseResize && moveBox.Inside(x, y))) {
		if (!buttonsTexture) { glColor4f(1.0f, 1.0f, 1.0f, 0.3f); }
		moveBox.DrawBox();
	}
	else if (!mouseMove && !mouseResize) {
		if (minimizeBox.Inside(x, y)) {
			if (!buttonsTexture) { glColor4f(1.0f, 0.2f, 0.2f, 0.6f); }
			minimizeBox.DrawBox();
		} else if (maximizeBox.Inside(x, y)) {
			if (!buttonsTexture) { glColor4f(1.0f, 1.0f, 1.0f, 0.3f); }
			maximizeBox.DrawBox();
		}
	}
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	// outline the button box
	glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
	glBegin(GL_LINE_LOOP);
		glVertex2f(float(buttonBox.xmin - 1 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 2 - 0.5f) * globalRendering->pixelY);
		glVertex2f(float(buttonBox.xmin - 1 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 2 + 0.5f) * globalRendering->pixelY);
		glVertex2f(float(buttonBox.xmax + 2 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 2 + 0.5f) * globalRendering->pixelY);
		glVertex2f(float(buttonBox.xmax + 2 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 2 - 0.5f) * globalRendering->pixelY);
	glEnd();

	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	glBegin(GL_LINE_LOOP);
		glVertex2f(float(buttonBox.xmin - 0 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 3 - 0.5f) * globalRendering->pixelY);
		glVertex2f(float(buttonBox.xmin - 0 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 1 + 0.5f) * globalRendering->pixelY);
		glVertex2f(float(buttonBox.xmax + 1 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 1 + 0.5f) * globalRendering->pixelY);
		glVertex2f(float(buttonBox.xmax + 1 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 3 - 0.5f) * globalRendering->pixelY);
	glEnd();
}
Пример #25
0
/*****************************************************************************
 * Draw the purple grid of lines, behind the Boing ball.
 * When the Workbench is dropped to the bottom, Boing shows 12 rows.
 *****************************************************************************/
void DrawGrid( void )
{
   int              row, col;
   const int        rowTotal    = 12;                   /* must be divisible by 2 */
   const int        colTotal    = rowTotal;             /* must be same as rowTotal */
   const GLfloat    widthLine   = 2.0;                  /* should be divisible by 2 */
   const GLfloat    sizeCell    = GRID_SIZE / rowTotal;
   const GLfloat    z_offset    = -40.0;
   GLfloat          xl, xr;
   GLfloat          yt, yb;

   glPushMatrix();
   glDisable( GL_CULL_FACE );

  /*
   * Another relative Z translation to separate objects.
   */
   glTranslatef( 0.0, 0.0, DIST_BALL );

  /*
   * Draw vertical lines (as skinny 3D rectangles).
   */
   for ( col = 0; col <= colTotal; col++ )
   {
     /*
      * Compute co-ords of line.
      */
      xl = -GRID_SIZE / 2 + col * sizeCell;
      xr = xl + widthLine;

      yt =  GRID_SIZE / 2;
      yb = -GRID_SIZE / 2 - widthLine;

      glBegin( GL_POLYGON );

      glColor3f( 0.6, 0.1, 0.6 );               /* purple */

      glVertex3f( xr, yt, z_offset );       /* NE */
      glVertex3f( xl, yt, z_offset );       /* NW */
      glVertex3f( xl, yb, z_offset );       /* SW */
      glVertex3f( xr, yb, z_offset );       /* SE */

      glEnd();
   }

  /*
   * Draw horizontal lines (as skinny 3D rectangles).
   */
   for ( row = 0; row <= rowTotal; row++ )
   {
     /*
      * Compute co-ords of line.
      */
      yt = GRID_SIZE / 2 - row * sizeCell;
      yb = yt - widthLine;

      xl = -GRID_SIZE / 2;
      xr =  GRID_SIZE / 2 + widthLine;

      glBegin( GL_POLYGON );

      glColor3f( 0.6, 0.1, 0.6 );               /* purple */

      glVertex3f( xr, yt, z_offset );       /* NE */
      glVertex3f( xl, yt, z_offset );       /* NW */
      glVertex3f( xl, yb, z_offset );       /* SW */
      glVertex3f( xr, yb, z_offset );       /* SE */

      glEnd();
   }

   glPopMatrix();

   return;
}
Пример #26
0
CMiniMap::CMiniMap()
: CInputReceiver(BACK),
  fullProxy(false),
  proxyMode(false),
  selecting(false),
  maxspect(false),
  maximized(false),
  minimized(false),
  mouseLook(false),
  mouseMove(false),
  mouseResize(false),
  slaveDrawMode(false),
  showButtons(false),
  useIcons(true)
 {
	lastWindowSizeX = globalRendering->viewSizeX;
	lastWindowSizeY = globalRendering->viewSizeY;

	if (globalRendering->dualScreenMode) {
		width = globalRendering->viewSizeX;
		height = globalRendering->viewSizeY;
		xpos = (globalRendering->viewSizeX - globalRendering->viewPosX);
		ypos = 0;
	}
	else {
		const std::string geo = configHandler->GetString("MiniMapGeometry");
		ParseGeometry(geo);
	}

	fullProxy = configHandler->GetBool("MiniMapFullProxy");
	buttonSize = configHandler->GetInt("MiniMapButtonSize");

	unitBaseSize = configHandler->GetFloat("MiniMapUnitSize");
	unitExponent = configHandler->GetFloat("MiniMapUnitExp");

	cursorScale = configHandler->GetFloat("MiniMapCursorScale");
	useIcons = configHandler->GetBool("MiniMapIcons");
	drawCommands = configHandler->GetInt("MiniMapDrawCommands");
	drawProjectiles = configHandler->GetBool("MiniMapDrawProjectiles");
	simpleColors = configHandler->GetBool("SimpleMiniMapColors");

	myColor[0]    = (unsigned char)(0.2f * 255);
	myColor[1]    = (unsigned char)(0.9f * 255);
	myColor[2]    = (unsigned char)(0.2f * 255);
	myColor[3]    = (unsigned char)(1.0f * 255);
	allyColor[0]  = (unsigned char)(0.3f * 255);
	allyColor[1]  = (unsigned char)(0.3f * 255);
	allyColor[2]  = (unsigned char)(0.9f * 255);
	allyColor[3]  = (unsigned char)(1.0f * 255);
	enemyColor[0] = (unsigned char)(0.9f * 255);
	enemyColor[1] = (unsigned char)(0.2f * 255);
	enemyColor[2] = (unsigned char)(0.2f * 255);
	enemyColor[3] = (unsigned char)(1.0f * 255);

	UpdateGeometry();

	circleLists = glGenLists(circleListsCount);
	for (int cl = 0; cl < circleListsCount; cl++) {
		glNewList(circleLists + cl, GL_COMPILE);
		glBegin(GL_LINE_LOOP);
		const int divs = (1 << (cl + 3));
		for (int d = 0; d < divs; d++) {
			const float rads = float(2.0 * PI) * float(d) / float(divs);
			glVertex3f(math::sin(rads), 0.0f, math::cos(rads));
		}
		glEnd();
		glEndList();
	}

	// setup the buttons' texture and texture coordinates
	buttonsTexture = 0;
	CBitmap bitmap;
	bool unfiltered = false;
	if (bitmap.Load("bitmaps/minimapbuttons.png")) {
		if ((bitmap.ysize == buttonSize) && (bitmap.xsize == (buttonSize * 4))) {
			unfiltered = true;
		}
		glGenTextures(1, &buttonsTexture);
		glBindTexture(GL_TEXTURE_2D, buttonsTexture);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
								 bitmap.xsize, bitmap.ysize, 0,
								 GL_RGBA, GL_UNSIGNED_BYTE, bitmap.mem);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
		if (unfiltered) {
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		} else {
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		}
		glBindTexture(GL_TEXTURE_2D, 0);
	}
	const float xshift = unfiltered ? 0.0f : (0.5f / bitmap.xsize);
	const float yshift = unfiltered ? 0.0f : (0.5f / bitmap.ysize);
	    moveBox.xminTx = 0.50f + xshift;
	    moveBox.xmaxTx = 0.75f - xshift;
	  resizeBox.xminTx = 0.75f + xshift;
	  resizeBox.xmaxTx = 1.00f - xshift;
	minimizeBox.xminTx = 0.00f + xshift;
	minimizeBox.xmaxTx = 0.25f - xshift;
	maximizeBox.xminTx = 0.25f + xshift;
	maximizeBox.xmaxTx = 0.50f - xshift;
	    moveBox.yminTx = 1.00f - yshift;
	  resizeBox.yminTx = 1.00f - yshift;
	minimizeBox.yminTx = 1.00f - yshift;
	maximizeBox.yminTx = 1.00f - yshift;
	    moveBox.ymaxTx = 0.00f + yshift;
	  resizeBox.ymaxTx = 0.00f + yshift;
	minimizeBox.ymaxTx = 0.00f + yshift;
	maximizeBox.ymaxTx = 0.00f + yshift;
}
Пример #27
0
void display()
{
    x_pos = R * cos(phi) * cos(theta);
    y_pos = R * sin(theta);
    z_pos = R * sin(phi) * cos(theta);

    glClearColor(0.0f, 1.0f, 1.0f, 0.0f);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    if (cos(theta) >= 0)
        gluLookAt(x_pos, y_pos, z_pos, 0, 0, 0, 0, 1, 0);
    else
        gluLookAt(x_pos, y_pos, z_pos, 0, 0, 0, 0, -1, 0);



    // the base plane (square)
    glColor3f(0.0, 0.0, 0.6);
    glTranslatef(0, -4, 0);
    glBegin(GL_POLYGON);
    glVertex3f(-G.baseEdge / 2, 0, -G.baseEdge / 2);
    glVertex3f(G.baseEdge / 2, 0, -G.baseEdge / 2);
    glVertex3f(G.baseEdge / 2, 0, G.baseEdge / 2);
    glVertex3f(-G.baseEdge / 2, 0, G.baseEdge / 2);
    glEnd();


    C = G.cuboids[j];
    C.setTranslation(C.getXT(), C.getYT() - y, C.getZT());

    float x, z, xa, xb, za, zb;

    if (j > 0)
    {

        float x = C.getXT();
        float z = C.getZT();

        float xa = G.cuboids[j - 1].getXT() - (G.cuboids[j - 1].getXS() / 2);
        float xb = G.cuboids[j - 1].getXT() + (G.cuboids[j - 1].getXS() / 2);
        float za = G.cuboids[j - 1].getZT() - (G.cuboids[j - 1].getZS() / 2);
        float zb = G.cuboids[j - 1].getZT() + (G.cuboids[j - 1].getZS() / 2);

        if (x >= xa && x <= xb && z >= za && z <= zb)
        {
            C.setColor(0.7, 0.0, 0.0);
            rightZone = true;
        } else rightZone = false;
    }


    bool GameOver = GameLose || GameWin;
    if (!GameOver)
        C.generateCuboid();

    if (!Pause)
        y += speed;
    else
        print_text((char*) "PAUSED", 3, 10, GLUT_BITMAP_TIMES_ROMAN_24, 1.0, 1.0, 0.0);

    if (y >= newHeight && !GameOver)
    {
        y = 0.0;
        speed = 0.02;
        C.setColor(0.0, 0.8, 0.0);
        G.cuboids[j] = C;

        newHeight -= G.cuboids[j].getYS() / 2 + G.cuboids[j + 1.2].getYS() / 2;
        if (newHeight < C.getYS())
        {
            GameWin = true;
            std::cout << "YOU WIN! Game over!" << std::endl;

        } else if (j > 0 && rightZone == false)
        {
            GameLose = true;
            std::cout << "YOU LOSE! Game over!" << std::endl;
        }
        j++;
    }


    if (GameWin) print_text((char*) "YOU WIN! Game over!", 3, 10, GLUT_BITMAP_TIMES_ROMAN_24, 1.0, 0.0, 1.0);
    if (GameLose) print_text((char*) "YOU LOOSE! Game over!", 3, 10, GLUT_BITMAP_TIMES_ROMAN_24, 1.0, 0.0, 1.0);

    if (j > 0)
    {
        C.setColor(0.8, 0.0, 0.0);
        for (int i = 0; i < j; i++)
        {
            G.cuboids[i].generateCuboid();
        }
    }



    glutSwapBuffers();
}
Пример #28
0
void Sector::draw(Renderer *renderer, ShaderID shader, TextureID *base, TextureID *bump, vec3 &position, vec3 &dx, vec3 &dy, bool useOcclusionQueries){
	unsigned int i, j;

	glEnable(GL_CULL_FACE);

	for (j = 0; j < lights.getCount(); j++){
		float t = time - 0.1f;

		mousehorizontal =  mousehorizontal + 200 * mousexxxxxx;
		mousevericle =  mousevericle - 200 * mouseyyyyyy;
		vec3 p = vec3(0, 500 - mouseY, mouseX);
		/*
		XWarpPointer(display, None, window, 0,0,0,0, middleX, middleY);
		static bool changeMouse;
		float mouseSensibility = 0.0005f * mouseSpeed;

		//app->rotateView(mouseSensibility * (middleY - event.xmotion.y) * (invertMouse? 1 : -1),
		//				mouseSensibility * (middleX - event.xmotion.x));

		if (changeMouse = !changeMouse) XWarpPointer(display, None, window, 0,0,0,0, middleX, middleY);
		vec3 p = vec3(mouseSensibility * (middleY - event.xmotion.y) * (invertMouse? 1 : -1),
						mouseSensibility * (middleX - event.xmotion.x), lights[j].zs * sinf(3.12f * t + j));
		*/
/*
		XEvent event;
		Display *display;
		display = XOpenDisplay(0);
		XNextEvent(display, &event);
		float mouseSensibility = 0.0005f * mouseSpeed;
		//vec3 p = vec3(mouseSensibility * (- event.xmotion.y) * (1),mouseSensibility * (- event.xmotion.x), 0;
		*/

		for (i = 0; i < room->getBatchCount(); i++){
			renderer->setShader(shader);
			renderer->setTexture("Base", base[i]);
			renderer->setTexture("Bump", bump[i]);
			if (j > 0) renderer->setBlending(ONE, ONE);
			renderer->apply();

			renderer->changeShaderConstant3f("lightPos", lights[j].position + p);
			renderer->changeShaderConstant3f("camPos", position);
			renderer->changeShaderConstant1f("invRadius", 1.0f / lights[j].radius);
			renderer->changeShaderConstant1f("ambient", (j > 0)? 0 : 0.07f);

			((OpenGLBatch *) room->getBatch(i))->draw();
		}
	}

	hasBeenDrawn = true;

	if (useOcclusionQueries){
		glDisable(GL_CULL_FACE);

		renderer->setMask(NONE);
		renderer->apply();

		for (i = 0; i < portals.getCount(); i++){
			if (portals[i].sector->hasBeenDrawn) continue;

			glBeginQueryARB(GL_SAMPLES_PASSED_ARB, portals[i].query);
			glBegin(GL_QUADS);
				glVertex3fv(portals[i].v0);
				glVertex3fv(portals[i].v1);
				glVertex3fv(portals[i].v2);
				glVertex3fv(portals[i].v3);
			glEnd();
			glEndQueryARB(GL_SAMPLES_PASSED_ARB);
		}

		glFlush();
	}

	// Do something useful while waiting for portals rendering to complete
	for (j = 0; j < lights.getCount(); j++){
		//vec3 p = vec3(lights[j].xs * cosf(4.23f * time + j), lights[j].ys * sinf(2.37f * time) * cosf(1.39f * time), lights[j].zs * sinf(3.12f * time + j));
//########################################################
		float a = 200, b= 200;
		//vec3 p = vec3(a,b,200);
		int aaa = 0;
		
		//mousehorizontal =  mousehorizontal + 200 * mousexxxxxx;
		//mousevericle =  mousevericle - 200 * mouseyyyyyy;
		aaa++;
		/*
		if (aaa == 2000){
			aaa = 0;
			mousehorizontal = 200;
			mousevericle = 200;
		}
		*/
		vec3 p = vec3(0, 500 -  mouseY, mouseX);
		printf("%f, %f, %f, %f\n", mouseY, mousehorizontal, mouseX, mousevericle);
		lights[j].particles->setPosition(p);
//lights[j].particles->setPosition(lights[j].position + p);
		lights[j].particles->update(time);
		lights[j].vertexArray = lights[j].particles->getVertexArray(dx, dy);
	}

	if (useOcclusionQueries){
		for (i = 0; i < portals.getCount(); i++){
			if (portals[i].sector->hasBeenDrawn) continue;

			GLuint samples = 0;
			glGetQueryObjectuivARB(portals[i].query, GL_QUERY_RESULT_ARB, &samples);

			if (samples > 100){
				portals[i].sector->draw(renderer, shader, base, bump, position, dx, dy, useOcclusionQueries);
			}
		}
	} else {
		for (i = 0; i < portals.getCount(); i++){
			if (!portals[i].sector->hasBeenDrawn){
				portals[i].sector->draw(renderer, shader, base, bump, position, dx, dy, useOcclusionQueries);
			}
		}
	}
}
Пример #29
0
int MREAData::MeshData::draw(clsMaterialHeader & materialHeader)
{
	//hey, any chance you could speed this function up? Hit the CPU kind of hard, I just added some pointer changes
	int Seg=0;
	int datasize=0;
	int HowToDraw=GL_POINTS;
	int subtract=0;
	u32 i=0;
	int j=0;
	int DontDraw=-1;
	unsigned char* pnt=NULL;
	int lastuv=0;
// 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen And Depth Buffer
// 	glLoadIdentity();									// Reset The Current Modelview Matrix
// 	glTranslatef(xCamera,yCamera,zCamera);						// Move Left 1.5 Units And Into The Screen 6.0
// 	// Drawing Using Triangles
	txtrinfo* info;
// 	//clsMaterialHeader* MaterialHeader;
// 	// mGroup* matGroup;
// 	glRotatef(xRot,1.0f,0.0f,0.0f);//Rotate x axis? o_O
// 	glRotatef(yRot,0.0f,1.0f,0.0f);
// 	glRotatef(zRot,0.0f,0.0f,1.0f);
	/*GLfloat Ambient[]= { 0.05f, 0.05f, 0.05f, 1.0f }; 				// Ambient Light Values ( NEW )
	GLfloat Diffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f };				 // Diffuse Light Values ( NEW )
	GLfloat Position[]= { 0.0f, 0.0f, 20.0f, 255.0f };				 // Light Position ( NEW )
	glLightfv(GL_LIGHT0, GL_AMBIENT, Ambient);				// Setup The Ambient Light
	glLightfv(GL_LIGHT0, GL_DIFFUSE, Diffuse);				// Setup The Diffuse Light
	glLightfv(GL_LIGHT0, GL_POSITION,Position);	*/		// Position The Light
	// rquad-=1.15f;

	//GL_POINTS);
	/*#define GL_POINTS                         0x0000
	#define GL_LINES                          0x0001
	#define GL_LINE_LOOP                      0x0002
	#define GL_LINE_STRIP                     0x0003
	#define GL_TRIANGLES                      0x0004
	#define GL_TRIANGLE_STRIP                 0x0005
	#define GL_TRIANGLE_FAN                   0x0006
	#define GL_QUADS                          0x0007
	#define GL_QUAD_STRIP                     0x0008
	#define GL_POLYGON                        0x0009
	*/
	//0x5d10	
	//glBindTexture(GL_TEXTURE_2D,CMDL.TextureIDs[1]);

	//if( CMDL.candraw!= 0)
	{
		//int index = lstMaterials.GetListIndex();
		//if(index<0) return 0;
		//MaterialHeader = &CMDL.MaterialHeader[index];

		u32 const vertexcount = (u32)vertices.size();
		u32 const normalcount = (u32)normals.size();
		u32 const uvcount = (u32)uvs.size();

		u32 l = 0;
		for (l = 0; l < 8; ++l)
		{
			glActiveTextureARB(GL_TEXTURE0_ARB + l);
			glBindTexture(GL_TEXTURE_2D, 0);
			glDisable(GL_TEXTURE_2D);
		}
		glActiveTextureARB(GL_TEXTURE0_ARB);

		glDisable(GL_LIGHTING);
		glDisable(GL_BLEND);

		glBegin(GL_POINTS);
		for (i = 0; i < vertexcount; ++i)
		{
			glColor4f(
				0.0f,
				0.0f,
				0.0f,
				1.0f
				);

			glVertex3f(
				(vertices[i].X),
				(vertices[i].Y),
				(vertices[i].Z)
				);
		}
		glEnd();

		glEnable(GL_LIGHTING);
		glEnable(GL_BLEND);

		u32 const meshCount = (u32)subMeshes.size();
		// NOTE: use this to control which mesh materials are rendered, currently only allows a range
		u32 materialStart = 0;
		u32 materialEnd = materialHeader.MaterialCount;
		u32 Materials = 0;
		for (Materials = materialStart; (Materials < materialEnd) && (Materials < materialHeader.MaterialCount); ++Materials)
		{
			u32 uMesh = 0, uSubMesh = 0;
			u32 meshStart = 0;
			u32 meshEnd = meshCount;
			for (uMesh = meshStart; (uMesh < meshEnd) && (uMesh < meshCount); ++uMesh)
			{
				struct_Mesh & mesh = subMeshes[uMesh];

				if (mesh.GroupId != Materials)
				{
					continue;
				}

				info = &materialHeader.MaterialSegment[mesh.GroupId].info;

				for (uSubMesh = 0; (uSubMesh < mesh.subMeshes.size()); ++uSubMesh)
				{
					struct_SubMesh & submesh = mesh.subMeshes[uSubMesh];

					if (submesh.primitiveFlags == 0 ||
						0 >= submesh.indexCount ||
						submesh.indices.empty())
					{
						continue;
					}

					glPolygonMode(GL_FRONT, GL_FILL );
					glPolygonMode(GL_BACK, GL_LINE );

					u32 k=0;
					u32 l = 0;
					// NOTE: use this to control which texture images to use, currently only allows a range
					u32 kStart = 1, kEnd = kStart + 1; //info->count;
					if (uvcount != 0)
					{
						for (k = kStart; k < kEnd && k < info->count; ++k)
						{
							if (k > 0 && (info->ids[k] == info->ids[k-1])) 
							{
								//break;
							}
							//I guess I can do my crappy little test here! XD

							glActiveTextureARB(GL_TEXTURE0_ARB + l);
							glEnable(GL_TEXTURE_2D);
							//for helment trans o.o
							glDisable( GL_BLEND );
							/*
							#define GL_ZERO                           0
							#define GL_ONE                            1
							#define GL_SRC_COLOR                      0x0300
							#define GL_ONE_MINUS_SRC_COLOR            0x0301
							#define GL_SRC_ALPHA                      0x0302
							#define GL_ONE_MINUS_SRC_ALPHA            0x0303
							#define GL_DST_ALPHA                      0x0304
							#define GL_ONE_MINUS_DST_ALPHA            0x0305
							*/
							// glColor4f(4,2,4,0);
							glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

							glBindTexture(GL_TEXTURE_2D, materialHeader.TexturesIDs[info->ids[k]]);
							//glDisable(GL_BLEND);
							//	glBindTexture(GL_TEXTURE_2D, CMDL.MaterialHeader.TexturesIDs[4]);
							if (k > 0)
							{
								//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
							}
							++l;
						}
					}
					for (; l < 8; ++l)
					{
						glActiveTextureARB(GL_TEXTURE0_ARB + l);
						glBindTexture(GL_TEXTURE_2D, 0);
						glDisable(GL_TEXTURE_2D);
					}
					glActiveTextureARB(GL_TEXTURE0_ARB);

					switch (submesh.primitiveFlags & 0xF8)
					{
					case 0xB8:
						glBegin(GL_POINTS);
						break;
					case 0xA8:
						glBegin(GL_LINES);
						break;
					case 0xB0:
						glBegin(GL_LINE_STRIP);
						break;
					case 0x90:
						glBegin(GL_TRIANGLES);
						break;
					case 0x98:
						glBegin(GL_TRIANGLE_STRIP);
						break;
					case 0xA0:
						glBegin(GL_TRIANGLE_FAN);
						break;
					case 0x80:
						glBegin(GL_QUADS);
						break;
					default:
						glBegin(GL_POINTS);
						break;
					}

					struct_Faces * pFaces = &submesh.indices.front();

					u32 vertexIndex = 0;
					u32 normalIndex = 0;

					for (i=0; (i < submesh.indexCount); ++i)
					{
						vertexIndex = pFaces[i].vertexIndex;
						if (vertexIndex >= vertexcount)
						{
							break;
						}
						normalIndex = pFaces[i].normalIndex;
						if (normalIndex >= normalcount)
						{
							normalIndex = vertexIndex;
						}

						l = 0;
						if (uvcount != 0)
						{
							//u32 k=0;
							//kStart = 0;
							//kEnd = info->count;
							for(k = kStart; k < kEnd && k < info->count; ++k)
							{
								if (k > 0 && (info->ids[k] == info->ids[k-1]))
								{
									//continue;
								}

								GLuint uvIndex = pFaces[i].uvIndex[1];
								// NOTE: this currently seems like a hack, not sure if this is how this should be done
								// will probably be fixed once the attribute information from the headers is known
								// 							if (info->count > mesh.format)
								// 							{
								// 								if (mesh.format > 0)
								// 								{
								// 									uvIndex = pFaces[i].uvIndex[mesh.format-1];
								// 								}
								// 								else
								// 								{
								// 									uvIndex = normalIndex;
								// 								}
								// 							}
								// 							else
								// 							{
								// 								uvIndex = pFaces[i].uvIndex[k];
								// 							}

								float a=0;
								float b=0;
								if (uvIndex < uvcount)
								{
									a = uvs[uvIndex].U;
									b = uvs[uvIndex].V;
								}

								//glColor4f(0.0f, 0.0f, 0.0f, 255.0f);       //define the alpha value
								//glBlendFunc(GL_ONE, GL_ONE );  //define blending factors

								glMultiTexCoord2fARB(
									GL_TEXTURE0_ARB + l,
									a,
									b
									);
							}

							++l;
						}

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

						if (normalIndex < normalcount && normalcount !=0)
						{
							glNormal3f(
								(normals[normalIndex].X),
								(normals[normalIndex].Y),
								(normals[normalIndex].Z)
								);
						}
						glVertex3f(
							(vertices[vertexIndex].X),
							(vertices[vertexIndex].Y),
							(vertices[vertexIndex].Z)
							);
					}

					glEnd();
					glPolygonMode(GL_FRONT_AND_BACK, GL_FILL );
				}
			}
		}
	}

	return TRUE;
}
Пример #30
0
static void erzeuge_objekt_liste (void){
  int i;
  float phi, r = 2.0, x, z;
  
  glNewList(objekt_liste, GL_COMPILE);
  
  glBegin (GL_POLYGON);
  glColor3f(1.0f,0.0f,0.0f);
  for (i = 0; i < n_vertices; i ++) {
    phi = 2 * 3.14159265359 * i / (float) n_vertices;
    x = r * cos (phi);
    z = r * sin (phi);
    glVertex3f(x, -3.0f, z);
  }
  glEnd ();
  glBegin (GL_POLYGON);
  glColor3f(1.0f,0.0f,0.0f);
  for (i = 0; i < n_vertices; i ++) {
    phi = 2 * 3.14159265359 * i / (float) n_vertices;
    x = r * cos (phi);
    z = r * sin (phi);
    glVertex3f(x, 3.0f, z);
  }
  glEnd ();

  glBegin(GL_TRIANGLE_FAN);
  glColor3f(1.0f,0.0f,0.0f);
  glVertex3f(0.0f, 0.0f, 0.0f);
  for (i = 0; i < n_vertices + 1; i ++) {
    phi = 2 * 3.14159265359 * i / (float) n_vertices;
    x = r * cos (phi);
    z = r * sin (phi);
    if (i%2 == 0){
      glColor3f(0.0f,1.0f,0.0f);
    }
    else{
      glColor3f(0.0f,0.0f,1.0f);
    }
    glVertex3f(x, -3.0f, z);
  }
  glEnd ();

  glBegin(GL_TRIANGLE_FAN);
  glColor3f(1.0f,0.0f,0.0f);
  glVertex3f(0.0f, 0.0f, 0.0f);
  for (i = 0; i < n_vertices + 1; i ++) {
    phi = 2 * 3.14159265359 * i / (float) n_vertices;
    x = r * cos (phi);
    z = r * sin (phi);
    if (i%2 == 0){
      glColor3f(0.0f,1.0f,0.0f);
    }
    else{
      glColor3f(0.0f,0.0f,1.0f);
    }
    glVertex3f(x, 3.0f, z);
  }
  glEnd ();

  glEndList();
}