void moEffectCubeMap::Draw( moTempo* tempogral,moEffectState* parentstate)
{
    PreDraw( tempogral,parentstate);

    glEnable(GL_DEPTH_TEST);							// Disables Depth Testing
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);

	glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
	glPushMatrix();										// Store The Projection Matrix
	glLoadIdentity();									// Reset The Projection Matrix
	//gluLookAt(0, 0, 0, 0, 0, 1, 0, 1, 0);
	gluPerspective(45,1.33f,0.0f,3.0f);
	glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
	glPushMatrix();										// Store The Modelview Matrix
	glLoadIdentity();									// Reset The Modelview Matrix


	glTranslatef(   m_Config[moR(CUBEMAP_TRANSLATEX)].GetData()->Fun()->Eval(state.tempo.ang),
					m_Config[moR(CUBEMAP_TRANSLATEY)].GetData()->Fun()->Eval(state.tempo.ang),
					m_Config[moR(CUBEMAP_TRANSLATEZ)].GetData()->Fun()->Eval(state.tempo.ang));

	glRotatef(  m_Config[moR(CUBEMAP_ROTATEX)].GetData()->Fun()->Eval(state.tempo.ang), 1.0, 0.0, 0.0 );
    glRotatef(  m_Config[moR(CUBEMAP_ROTATEY)].GetData()->Fun()->Eval(state.tempo.ang), 0.0, 1.0, 0.0 );
    glRotatef(  m_Config[moR(CUBEMAP_ROTATEZ)].GetData()->Fun()->Eval(state.tempo.ang), 0.0, 0.0, 1.0 );
	glScalef(   m_Config[moR(CUBEMAP_SCALEX)].GetData()->Fun()->Eval(state.tempo.ang),
                m_Config[moR(CUBEMAP_SCALEY)].GetData()->Fun()->Eval(state.tempo.ang),
                m_Config[moR(CUBEMAP_SCALEZ)].GetData()->Fun()->Eval(state.tempo.ang));

	glColor4f(  m_Config[moR(CUBEMAP_COLOR)][MO_SELECTED][MO_RED].Fun()->Eval(state.tempo.ang) * state.tintr,
                m_Config[moR(CUBEMAP_COLOR)][MO_SELECTED][MO_GREEN].Fun()->Eval(state.tempo.ang) * state.tintg,
                m_Config[moR(CUBEMAP_COLOR)][MO_SELECTED][MO_BLUE].Fun()->Eval(state.tempo.ang) * state.tintb,
				m_Config[moR(CUBEMAP_COLOR)][MO_SELECTED][MO_ALPHA].Fun()->Eval(state.tempo.ang) *
				m_Config[moR(CUBEMAP_ALPHA)].GetData()->Fun()->Eval(state.tempo.ang) * state.alpha);

    moTexture* pImageLeft = (moTexture*) m_Config[moR(CUBEMAP_TEXTURELEFT)].GetData()->Pointer();
    moTexture* pImageRight = (moTexture*) m_Config[moR(CUBEMAP_TEXTURERIGHT)].GetData()->Pointer();
    moTexture* pImageFront = (moTexture*) m_Config[moR(CUBEMAP_TEXTUREFRONT)].GetData()->Pointer();
    moTexture* pImageBack = (moTexture*) m_Config[moR(CUBEMAP_TEXTUREBACK)].GetData()->Pointer();
    moTexture* pImageTop = (moTexture*) m_Config[moR(CUBEMAP_TEXTURETOP)].GetData()->Pointer();
    moTexture* pImageBottom = (moTexture*) m_Config[moR(CUBEMAP_TEXTUREBOTTOM)].GetData()->Pointer();

  //front
  glBindTexture( GL_TEXTURE_2D, m_Config[moR(CUBEMAP_TEXTUREFRONT)].GetData()->GetGLId(&state.tempo, 1, NULL ) );
  glBegin(GL_QUADS);
    glTexCoord2f(pImageFront->GetMaxCoordS(),0);
    glVertex3f(-1,-1,-1);
    glTexCoord2f(0,0);
    glVertex3f(1,-1,-1);
    glTexCoord2f(0,pImageFront->GetMaxCoordT());
    glVertex3f(1,1,-1);
    glTexCoord2f(pImageFront->GetMaxCoordS(),pImageFront->GetMaxCoordT());
    glVertex3f(-1,1,-1);
  glEnd();

//up
  glBindTexture( GL_TEXTURE_2D, m_Config[moR(CUBEMAP_TEXTURETOP)].GetData()->GetGLId(&state.tempo, 1, NULL ) );
  glBegin(GL_QUADS);
    glTexCoord2f(pImageTop->GetMaxCoordS(),0);
    glVertex3f(-1,1,-1);
    glTexCoord2f(0,0);
    glVertex3f(1,1,-1);
    glTexCoord2f(0,pImageTop->GetMaxCoordT());
    glVertex3f(1,1,1);
    glTexCoord2f(pImageTop->GetMaxCoordS(),pImageTop->GetMaxCoordT());
    glVertex3f(-1,1,1);
  glEnd();

  //left
  glBindTexture( GL_TEXTURE_2D, m_Config[moR(CUBEMAP_TEXTURELEFT)].GetData()->GetGLId(&state.tempo, 1, NULL ) );
  glBegin(GL_QUADS);
    glTexCoord2f(pImageLeft->GetMaxCoordS(),pImageLeft->GetMaxCoordT());
    glVertex3f(-1,1,1);
    glTexCoord2f(0,pImageLeft->GetMaxCoordT());
    glVertex3f(-1,1,-1);
    glTexCoord2f(0,0);
    glVertex3f(-1,-1,-1);
    glTexCoord2f(pImageLeft->GetMaxCoordS(),0);
    glVertex3f(-1,-1,1);
  glEnd();

  //right
  glBindTexture( GL_TEXTURE_2D, m_Config[moR(CUBEMAP_TEXTURERIGHT)].GetData()->GetGLId(&state.tempo, 1, NULL ) );
  glBegin(GL_QUADS);
    glTexCoord2f(0,pImageRight->GetMaxCoordT());
    glVertex3f(1,1,1);
    glTexCoord2f(pImageRight->GetMaxCoordS(),pImageRight->GetMaxCoordT());
    glVertex3f(1,1,-1);
    glTexCoord2f(pImageRight->GetMaxCoordS(),0);
    glVertex3f(1,-1,-1);
    glTexCoord2f(0,0);
    glVertex3f(1,-1,1);
  glEnd();

  //down
  glBindTexture( GL_TEXTURE_2D, m_Config[moR(CUBEMAP_TEXTUREBOTTOM)].GetData()->GetGLId(&state.tempo, 1, NULL ) );
  glBegin(GL_QUADS);
    glTexCoord2f(pImageBottom->GetMaxCoordS(),pImageBottom->GetMaxCoordT());
    glVertex3f(-1,-1,-1);
    glTexCoord2f(0,pImageBottom->GetMaxCoordT());
    glVertex3f(1,-1,-1);
    glTexCoord2f(0,0);
    glVertex3f(1,-1,1);
    glTexCoord2f(pImageBottom->GetMaxCoordS(),0);
    glVertex3f(-1,-1,1);
  glEnd();


  //back
  glBindTexture( GL_TEXTURE_2D, m_Config[moR(CUBEMAP_TEXTUREBACK)].GetData()->GetGLId(&state.tempo, 1, NULL ) );
  glBegin(GL_QUADS);
    glTexCoord2f(0,0);
    glVertex3f(-1,-1,1);
    glTexCoord2f(pImageBack->GetMaxCoordS(),0);
    glVertex3f(1,-1,1);
    glTexCoord2f(pImageBack->GetMaxCoordS(),pImageBack->GetMaxCoordT());
    glVertex3f(1,1,1);
    glTexCoord2f(0,pImageBack->GetMaxCoordT());
    glVertex3f(-1,1,1);
  glEnd();

    glMatrixMode(GL_MODELVIEW);							// Select The Modelview Matrix
	glPopMatrix();
	glMatrixMode(GL_PROJECTION);						// Select The Projection Matrix
	glPopMatrix();										// Restore The Old Projection Matrix

}
Exemple #2
0
void RenderScene()
{
    // This is the last function that we need explaining for this tutorial.
    // We have done all the shadow mapping work above this, but we still haven't
    // gone over actually rendering the depth values of the light's view to a
    // texture.  Let's go over each line and see how this is done.  It's simple.

    // Since our light is moving every frame we will need to update the light's
    // matrices.  We really only need to update the modelview matrix every frame,
    // but we do the projection matrix too just to make it a simple function call.
    // If your light never moves, you only need to call this function once.
    StoreLightMatrices();

    // Clear the screen and depth buffer so we can render from the light's view
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    // Since our texture map that will store the depth values is a different size
    // than our normal viewport, we need to change the viewport to make it the same
    // size as our texture.
    glViewport(0, 0, (int)SHADOW_WIDTH, (int)SHADOW_HEIGHT);

    // Now we just need to set the matrices for the light before we render.
    // We switch to projection mode and input our light's projection matrix.
    glMatrixMode(GL_PROJECTION);

    // Push on a matrix to make sure we can restore to the old matrix easily
    glPushMatrix();

    // Set the current projection matrix to our light's projection matrix
    glLoadMatrixf(g_mProjection);

    // Load modelview mode to set our light's modelview matrix
    glMatrixMode(GL_MODELVIEW);

    // Load the light's modelview matrix before we render to a texture
    glLoadMatrixf(g_mModelView);

    // Since we don't care about color when rendering the depth values to
    // the shadow-map texture, we disable color writing to increase speed.
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

    // This special function fixes artifacts that lead to small errors when
    // calculating the shadow map.  You will need to adjust the scale depending
    // on your scene, but I chose the scale 8.0 for mine.  NVIDIA suggests 1.1
    // or higher.  The 4.0 should stay fairly the same.
    glPolygonOffset(8.0f, 4.0f);

    // This turns of the polygon offset functionality to fix artifacts.
    // Comment this out and run the program to see what artifacts I mean.
    glEnable(GL_POLYGON_OFFSET_FILL);

    // Render the world according to the light's view
    RenderWorld();

    // Now that the world is rendered, save the depth values to a texture
    glBindTexture(GL_TEXTURE_2D, g_Texture[SHADOW_ID]);
    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, (int)SHADOW_WIDTH, (int)SHADOW_HEIGHT);

    // We can turn color writing back on since we already stored the depth values
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    // Turn off polygon offsetting
    glDisable(GL_POLYGON_OFFSET_FILL);

    // Restore our normal viewport size to our screen width and height
    glViewport(0, 0, (int)SCREEN_WIDTH, (int)SCREEN_HEIGHT);

    // Go back to the projection mode and restore the original matrix
    glMatrixMode(GL_PROJECTION);

    // Restore the original projection matrix
    glPopMatrix();

    // Go back to modelview model to start drawing like normal
    glMatrixMode(GL_MODELVIEW);

    // Clear the color and depth bits and start over from the camera's view
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    g_Camera.Look();

    // Render the world and apply the shadow map texture to it
    ApplyShadowMap();

    // The rest of the code below just draws and moves the light.  You don't need it.

    GLUquadricObj *pObj = gluNewQuadric();				// Get a Quadric off the stack
    gluQuadricDrawStyle(pObj, GLU_FILL);				// Draw the sphere normally

    // Draw the light at the light's position
    glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
    glTranslatef(g_LightPosition[0], g_LightPosition[1], g_LightPosition[2]);
    gluSphere(pObj, 0.05f, 25, 25);

    gluDeleteQuadric(pObj);								// Free the Quadric

    SwapBuffers(g_hDC);									// Swap the backbuffers to the foreground

    // If the light position goes out of the screen to the left, reset the direction and position.
    if(g_LightPosition[0] < -2.0f)
    {
        g_Direction = g_Direction * -1;
        g_LightPosition[0] = -2.0f;
    }
    // If the light position goes out of the screen to the right, reset the direction and position.
    if(g_LightPosition[0] > 2.0f)
    {
        g_Direction = g_Direction * -1;
        g_LightPosition[0] = 2.0f;
    }

    // Each frame we move the light by the current direction, then update the light with GL.
    g_LightPosition[0] += g_Direction;
    glLightfv( GL_LIGHT0, GL_POSITION, g_LightPosition );
}
Exemple #3
0
/*
=================
R_DrawAliasModel

=================
*/
void R_DrawAliasModel (entity_t *e)
{
	int			i;
	int			lnum;
	vec3_t		dist;
	float		add;
	model_t		*clmodel;
	vec3_t		mins, maxs;
	aliashdr_t	*paliashdr;
	float		an;
	int			anim;

	clmodel = currententity->model;

	VectorAdd (currententity->origin, clmodel->mins, mins);
	VectorAdd (currententity->origin, clmodel->maxs, maxs);

	if (R_CullBox (mins, maxs))
		return;


	VectorCopy (currententity->origin, r_entorigin);
	VectorSubtract (r_origin, r_entorigin, modelorg);

	//
	// get lighting information
	//

	ambientlight = shadelight = R_LightPoint (currententity->origin);

	// allways give the gun some light
	if (e == &cl.viewent && ambientlight < 24)
		ambientlight = shadelight = 24;

	for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
	{
		if (cl_dlights[lnum].die >= cl.time)
		{
			VectorSubtract (currententity->origin,
							cl_dlights[lnum].origin,
							dist);
			add = cl_dlights[lnum].radius - Length(dist);

			if (add > 0) {
				ambientlight += add;
				//ZOID models should be affected by dlights as well
				shadelight += add;
			}
		}
	}

	// clamp lighting so it doesn't overbright as much
	if (ambientlight > 128)
		ambientlight = 128;
	if (ambientlight + shadelight > 192)
		shadelight = 192 - ambientlight;

	// ZOID: never allow players to go totally black
	i = currententity - cl_entities;
	if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */)
		if (ambientlight < 8)
			ambientlight = shadelight = 8;

	// HACK HACK HACK -- no fullbright colors, so make torches full light
	if (!Q_strcmp (clmodel->name, "progs/flame2.mdl")
		|| !Q_strcmp (clmodel->name, "progs/flame.mdl") )
		ambientlight = shadelight = 256;

	shadedots = r_avertexnormal_dots[((int)(e->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)];
	shadelight = shadelight / 200.0;
	
	an = e->angles[1]/180*M_PI;
	shadevector[0] = cos(-an);
	shadevector[1] = sin(-an);
	shadevector[2] = 1;
	VectorNormalize (shadevector);

	//
	// locate the proper data
	//
	paliashdr = (aliashdr_t *)Mod_Extradata (currententity->model);

	c_alias_polys += paliashdr->numtris;

	//
	// draw all the triangles
	//

	GL_DisableMultitexture();

    glPushMatrix ();
	R_RotateForEntity (e);

	if (!Q_strcmp (clmodel->name, "progs/eyes.mdl") && gl_doubleeyes.value) {
		glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2] - (22 + 8));
// double size of eyes, since they are really hard to see in gl
		glScalef (paliashdr->scale[0]*2, paliashdr->scale[1]*2, paliashdr->scale[2]*2);
	} else {
		glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2]);
		glScalef (paliashdr->scale[0], paliashdr->scale[1], paliashdr->scale[2]);
	}

	anim = (int)(cl.time*10) & 3;
    GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]);

	// we can't dynamically colormap textures, so they are cached
	// seperately for the players.  Heads are just uncolored.
	if (currententity->colormap != vid.colormap && !gl_nocolors.value)
	{
		i = currententity - cl_entities;
		if (i >= 1 && i<=cl.maxclients /* && !Q_strcmp (currententity->model->name, "progs/player.mdl") */)
		    GL_Bind(playertextures - 1 + i);
	}

	if (gl_smoothmodels.value)
		glShadeModel (GL_SMOOTH);
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

	if (gl_affinemodels.value)
		glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);

	R_SetupAliasFrame (currententity->frame, paliashdr);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

	glShadeModel (GL_FLAT);
	if (gl_affinemodels.value)
		glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

	glPopMatrix ();

	if (r_shadows.value)
	{
		glPushMatrix ();
		R_RotateForEntity (e);
		glDisable (GL_TEXTURE_2D);
		glEnable (GL_BLEND);
		glColor4f (0,0,0,0.5);
		GL_DrawAliasShadow (paliashdr, lastposenum);
		glEnable (GL_TEXTURE_2D);
		glDisable (GL_BLEND);
		glColor4f (1,1,1,1);
		glPopMatrix ();
	}

}
Exemple #4
0
void Circle3DOverlay::render(RenderArgs* args) {
    if (!_visible) {
        return; // do nothing if we're not visible
    }

    float alpha = getAlpha();

    if (alpha == 0.0) {
        return; // do nothing if our alpha is 0, we're not visible
    }
    
    // Create the circle in the coordinates origin
    float outerRadius = getOuterRadius();
    float innerRadius = getInnerRadius(); // only used in solid case
    float startAt = getStartAt();
    float endAt = getEndAt();
    
    bool geometryChanged = (startAt != _lastStartAt || endAt != _lastEndAt ||
                                innerRadius != _lastInnerRadius || outerRadius != _lastOuterRadius);

    
    const float FULL_CIRCLE = 360.0f;
    const float SLICES = 180.0f;  // The amount of segment to create the circle
    const float SLICE_ANGLE = FULL_CIRCLE / SLICES;

    //const int slices = 15;
    xColor color = getColor();
    const float MAX_COLOR = 255.0f;
    glColor4f(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);


    glDisable(GL_LIGHTING);
    
    glm::vec3 position = getPosition();
    glm::vec3 center = getCenter();
    glm::vec2 dimensions = getDimensions();
    glm::quat rotation = getRotation();

    float glowLevel = getGlowLevel();
    Glower* glower = NULL;
    if (glowLevel > 0.0f) {
        glower = new Glower(glowLevel);
    }

    glPushMatrix();
        glTranslatef(position.x, position.y, position.z);
        glm::vec3 axis = glm::axis(rotation);
        glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
        glPushMatrix();
            glm::vec3 positionToCenter = center - position;
            glTranslatef(positionToCenter.x, positionToCenter.y, positionToCenter.z);
            glScalef(dimensions.x, dimensions.y, 1.0f);

            glLineWidth(_lineWidth);

            auto geometryCache = DependencyManager::get<GeometryCache>();
            
            // for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
            // we just draw a line...
            if (getIsSolid()) {
                if (_quadVerticesID == GeometryCache::UNKNOWN_ID) {
                    _quadVerticesID = geometryCache->allocateID();
                }
                
                if (geometryChanged) {
                    
                    QVector<glm::vec2> points;

                    float angle = startAt;
                    float angleInRadians = glm::radians(angle);
                    glm::vec2 firstInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
                    glm::vec2 firstOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);

                    points << firstInnerPoint << firstOuterPoint;

                    while (angle < endAt) {
                        angleInRadians = glm::radians(angle);
                        glm::vec2 thisInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
                        glm::vec2 thisOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);

                        points << thisOuterPoint << thisInnerPoint;
                
                        angle += SLICE_ANGLE;
                    }
            
                    // get the last slice portion....
                    angle = endAt;
                    angleInRadians = glm::radians(angle);
                    glm::vec2 lastInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
                    glm::vec2 lastOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
            
                    points << lastOuterPoint << lastInnerPoint;

                    geometryCache->updateVertices(_quadVerticesID, points);
                }
                
                geometryCache->renderVertices(GL_QUAD_STRIP, _quadVerticesID);

            } else {
                if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {
                    _lineVerticesID = geometryCache->allocateID();
                }

                if (geometryChanged) {
                    QVector<glm::vec2> points;
                    
                    float angle = startAt;
                    float angleInRadians = glm::radians(angle);
                    glm::vec2 firstPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
                    points << firstPoint;

                    while (angle < endAt) {
                        angle += SLICE_ANGLE;
                        angleInRadians = glm::radians(angle);
                        glm::vec2 thisPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
                        points << thisPoint;

                        if (getIsDashedLine()) {
                            angle += SLICE_ANGLE / 2.0f; // short gap
                            angleInRadians = glm::radians(angle);
                            glm::vec2 dashStartPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
                            points << dashStartPoint;
                        }
                    }
            
                    // get the last slice portion....
                    angle = endAt;
                    angleInRadians = glm::radians(angle);
                    glm::vec2 lastPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
                    points << lastPoint;

                    geometryCache->updateVertices(_lineVerticesID, points);
                }

                if (getIsDashedLine()) {
                    geometryCache->renderVertices(GL_LINES, _lineVerticesID);
                } else {
                    geometryCache->renderVertices(GL_LINE_STRIP, _lineVerticesID);
                }
            }
            
            // draw our tick marks
            // for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
            // we just draw a line...
            if (getHasTickMarks()) {

                if (_majorTicksVerticesID == GeometryCache::UNKNOWN_ID) {
                    _majorTicksVerticesID = geometryCache->allocateID();
                }
                if (_minorTicksVerticesID == GeometryCache::UNKNOWN_ID) {
                    _minorTicksVerticesID = geometryCache->allocateID();
                }

                if (geometryChanged) {
                    QVector<glm::vec2> majorPoints;
                    QVector<glm::vec2> minorPoints;

                    // draw our major tick marks
                    if (getMajorTickMarksAngle() > 0.0f && getMajorTickMarksLength() != 0.0f) {
                
                        float tickMarkAngle = getMajorTickMarksAngle();
                        float angle = startAt - fmod(startAt, tickMarkAngle) + tickMarkAngle; 
                        float angleInRadians = glm::radians(angle);
                        float tickMarkLength = getMajorTickMarksLength();
                        float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
                        float endRadius = startRadius + tickMarkLength;

                        while (angle <= endAt) {
                            angleInRadians = glm::radians(angle);

                            glm::vec2 thisPointA(cos(angleInRadians) * startRadius, sin(angleInRadians) * startRadius);
                            glm::vec2 thisPointB(cos(angleInRadians) * endRadius, sin(angleInRadians) * endRadius);

                            majorPoints << thisPointA << thisPointB;
                
                            angle += tickMarkAngle;
                        }
                    }

                    // draw our minor tick marks
                    if (getMinorTickMarksAngle() > 0.0f && getMinorTickMarksLength() != 0.0f) {
                
                        float tickMarkAngle = getMinorTickMarksAngle();
                        float angle = startAt - fmod(startAt, tickMarkAngle) + tickMarkAngle; 
                        float angleInRadians = glm::radians(angle);
                        float tickMarkLength = getMinorTickMarksLength();
                        float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
                        float endRadius = startRadius + tickMarkLength;

                        while (angle <= endAt) {
                            angleInRadians = glm::radians(angle);

                            glm::vec2 thisPointA(cos(angleInRadians) * startRadius, sin(angleInRadians) * startRadius);
                            glm::vec2 thisPointB(cos(angleInRadians) * endRadius, sin(angleInRadians) * endRadius);

                            minorPoints << thisPointA << thisPointB;
                
                            angle += tickMarkAngle;
                        }
                    }

                    geometryCache->updateVertices(_majorTicksVerticesID, majorPoints);
                    geometryCache->updateVertices(_minorTicksVerticesID, minorPoints);
                }

                xColor majorColor = getMajorTickMarksColor();
                glColor4f(majorColor.red / MAX_COLOR, majorColor.green / MAX_COLOR, majorColor.blue / MAX_COLOR, alpha);
                geometryCache->renderVertices(GL_LINES, _majorTicksVerticesID);

                xColor minorColor = getMinorTickMarksColor();
                glColor4f(minorColor.red / MAX_COLOR, minorColor.green / MAX_COLOR, minorColor.blue / MAX_COLOR, alpha);
                geometryCache->renderVertices(GL_LINES, _minorTicksVerticesID);
            }
            
 
        glPopMatrix();
    glPopMatrix();
    
    if (geometryChanged) {
        _lastStartAt = startAt;
        _lastEndAt = endAt;
        _lastInnerRadius = innerRadius;
        _lastOuterRadius = outerRadius;
    }
    
    if (glower) {
        delete glower;
    }
}
Exemple #5
0
void display() 
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		     // Clear Screen and Depth Buffer
	glLoadIdentity();
	glTranslatef(0.0f,0.0f,-10.0f);			
	keyOperations();
	// glRotatef(initialy, 0.0f, 1.0f, 0.0f);
	gluLookAt(initialx,1,initialz,
		initialx-sin(rotY),1,initialz-cos(rotY),
		0,1,0);
	// glTranslatef(0.0f, 0.0f, initialz);
	
	glPushMatrix();
	glTranslatef(6,-2.00,5);
	/*
	* drawing the enclosing box
	*/
	glColor3f(0.5f, 0.8f, 0.5f);
	glBindTexture(GL_TEXTURE_2D, texture[1]);
	glBegin(GL_QUADS);
	for (int i = -100.0; i < 250.0f; i+=25.0f)
	{
		for (int j = -100.0f; j < 100.0f; j+=25.0f)
		{
			glTexCoord2f(0.0, 0.0);
				glVertex3f(j,-0.0001f, i+25.0f);
			glTexCoord2f(0.0, 1.0);
				glVertex3f(j,-0.0001f,i);
			glTexCoord2f(1.0, 1.0);
				glVertex3f(j+25.0f,-0.0001f,i);
			glTexCoord2f(1.0, 0.0);
				glVertex3f(j+25.0f,-0.0001f, i+25.0f);			
		}
	}
	glEnd();
	glColor3f(0.75f, 0.75f, 0.75f);
	glBindTexture(GL_TEXTURE_2D, texture[2]);
	// DrawEnclosingSphere(300, 10, 10);
	glBegin(GL_QUADS);
	for (int i = -100.0; i < 250.0f; i+=25.0f)
	{
		for (int j = -100.0f; j < 100.0f; j+=25.0f)
		{
			glTexCoord2f(0.0, 0.0);
				glVertex3f(j,25.0f, i+25.0f);
			glTexCoord2f(0.0, 1.0);
				glVertex3f(j,25.0f,i);
			glTexCoord2f(1.0, 1.0);
				glVertex3f(j+25.0f,25.0f,i);
			glTexCoord2f(1.0, 0.0);
				glVertex3f(j+25.0f,25.0f, i+25.0f);			
		}
	}
	glEnd();

	glColor3f(1.0f, 1.0f, 1.0f);
	// glBindTexture(GL_TEXTURE_2D, texture[3]);
	// DrawEnclosingSphere(300, 10, 10);
	glBegin(GL_QUADS);
	for (int i = -100.0f; i < 100.0f; i+=25.0f)
	{
		glTexCoord2f(0.0, 0.0);
			glVertex3f(i, 0.0f, -100.0f);
		glTexCoord2f(1.0, 0.0);
			glVertex3f(i + 25.0f, 0.0f, -100.0f);
		glTexCoord2f(1.0, 1.0);
			glVertex3f(i + 25.0f, 25.0f, -100.0f);
		glTexCoord2f(0.0, 1.0);
			glVertex3f(i, 25.0f, -100.0f);
	}
	for (int i = -100.0f; i < 100.0f; i+=25.0f)
	{
		glTexCoord2f(0.0, 0.0);
			glVertex3f(i, 0.0f, 250.0f);
		glTexCoord2f(1.0, 0.0);
			glVertex3f(i + 25.0f, 0.0f, 250.0f);
		glTexCoord2f(1.0, 1.0);
			glVertex3f(i + 25.0f, 25.0f, 250.0f);
		glTexCoord2f(0.0, 1.0);
			glVertex3f(i, 25.0f, 250.0f);
	}
		for (int i = -100.0f; i < 250.0f; i+=25.0f)
	{
		glTexCoord2f(0.0, 0.0);
			glVertex3f(-100.0f, 0.0f,i);
		glTexCoord2f(1.0, 0.0);
			glVertex3f(-100.0f, 0.0f,i+25.0f);
		glTexCoord2f(1.0, 1.0);
			glVertex3f(-100.0f, 25.0f,i+25.0f);
		glTexCoord2f(0.0, 1.0);
			glVertex3f(-100.0f, 25.0f,i);
	}
		for (int i = -100.0f; i < 250.0f; i+=25.0f)
	{
		glTexCoord2f(0.0, 0.0);
			glVertex3f(100.0f, 0.0f,i);
		glTexCoord2f(1.0, 0.0);
			glVertex3f(100.0f, 0.0f,i+25.0f);
		glTexCoord2f(1.0, 1.0);
			glVertex3f(100.0f, 25.0f,i+25.0f);
		glTexCoord2f(0.0, 1.0);
			glVertex3f(100.0f, 25.0f,i);
	}
	glEnd();

	/*
	* drawing the track
	*/
	glColor3f(3.0f,3.0f,3.0f);
	glBindTexture(GL_TEXTURE_2D, texture[0]);
	if (currTrack.id == 2) {
		glBegin(GL_QUADS);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -69.6982f, 0.0000f, 146.3044f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -44.6982f, 0.0000f, 146.3044f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -44.6982f, 0.0000f, -3.6956f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -69.6982f, 0.0000f, -3.6956f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -69.6982f, 0.0000f, -3.6956f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -44.6982f, 0.0000f, -3.6956f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -41.5202f, 0.0000f, -20.8055f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -65.0125f, 0.0000f, -29.3560f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -65.0125f, 0.0000f, -29.3560f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -41.5202f, 0.0000f, -20.8055f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -32.8378f, 0.0000f, -35.8439f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -51.9889f, 0.0000f, -51.9136f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -51.9889f, 0.0000f, -51.9136f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -32.8378f, 0.0000f, -35.8439f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -19.5355f, 0.0000f, -47.0058f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -32.0355f, 0.0000f, -68.6564f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -32.0355f, 0.0000f, -68.6564f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -19.5355f, 0.0000f, -47.0058f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -3.2180f, 0.0000f, -52.9449f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -7.5592f, 0.0000f, -77.5651f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -7.5592f, 0.0000f, -77.5651f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -3.2180f, 0.0000f, -52.9449f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 14.1469f, 0.0000f, -52.9449f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 18.4881f, 0.0000f, -77.5651f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 18.4881f, 0.0000f, -77.5651f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 14.1469f, 0.0000f, -52.9449f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 30.4644f, 0.0000f, -47.0058f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 42.9644f, 0.0000f, -68.6564f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 42.9644f, 0.0000f, -68.6564f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 30.4644f, 0.0000f, -47.0058f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 43.7667f, 0.0000f, -35.8439f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 62.9178f, 0.0000f, -51.9136f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 62.9178f, 0.0000f, -51.9136f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 43.7667f, 0.0000f, -35.8439f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 52.4491f, 0.0000f, -20.8055f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 75.9414f, 0.0000f, -29.3560f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 75.9414f, 0.0000f, -29.3560f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 52.4491f, 0.0000f, -20.8055f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 55.4644f, 0.0000f, -3.7045f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 80.4644f, 0.0000f, -3.7045f);

			glTexCoord2f(0.0, 0.0);
			 glVertex3f( 80.4644f, 0.0000f, -3.7045f);
			glTexCoord2f(1.0, 0.0);
			 glVertex3f( 55.4644f, 0.0000f, -3.7045f);
			glTexCoord2f(1.0, 1.0);
			 glVertex3f( 55.4316f, 0.0000f, 146.3044f);
			glTexCoord2f(0.0, 1.0);
			 glVertex3f( 80.4316f, 0.0000f, 146.3044f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 80.4316f, 0.0000f, 146.3044f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 55.4316f, 0.0000f, 146.3044f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 52.4491f, 0.0000f, 163.3138f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 75.9414f, 0.0000f, 171.8643f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 75.9414f, 0.0000f, 171.8643f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 52.4491f, 0.0000f, 163.3138f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 43.7667f, 0.0000f, 178.3522f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 62.9178f, 0.0000f, 194.4219f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 62.9178f, 0.0000f, 194.4219f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 43.7667f, 0.0000f, 178.3522f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 30.4644f, 0.0000f, 189.5141f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 42.9644f, 0.0000f, 211.1647f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 42.9644f, 0.0000f, 211.1647f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 30.4644f, 0.0000f, 189.5141f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 14.1468f, 0.0000f, 195.4532f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 18.4880f, 0.0000f, 220.0734f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 18.4880f, 0.0000f, 220.0734f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 14.1468f, 0.0000f, 195.4532f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -3.2180f, 0.0000f, 195.4532f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -7.5592f, 0.0000f, 220.0734f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -7.5592f, 0.0000f, 220.0734f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -3.2180f, 0.0000f, 195.4532f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -19.5356f, 0.0000f, 189.5141f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -32.0356f, 0.0000f, 211.1647f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -32.0356f, 0.0000f, 211.1647f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -19.5356f, 0.0000f, 189.5141f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -32.8378f, 0.0000f, 178.3522f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -51.9889f, 0.0000f, 194.4219f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -51.9889f, 0.0000f, 194.4219f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -32.8378f, 0.0000f, 178.3522f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -41.5202f, 0.0000f, 163.3138f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -65.0125f, 0.0000f, 171.8643f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -65.0125f, 0.0000f, 171.8643f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( -41.5202f, 0.0000f, 163.3138f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( -44.6982f, 0.0000f, 146.3044f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( -69.6982f, 0.0000f, 146.3044f);

		glEnd();
	}
	else if (currTrack.id == 3) {	
		glTranslatef(-40.0f, 0.0f, 100.0f);
		glBegin(GL_QUADS);
		
		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 0.2048f, 0.0000f, 16.3703f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 0.2048f, 0.0000f, 86.3703f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 25.2048f, 0.0000f, 86.3703f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 25.2048f, 0.0000f, 16.3703f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 29.8147f, 0.0000f, -53.3839f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 0.2048f, 0.0000f, 16.3703f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 25.2048f, 0.0000f, 16.3703f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 54.8147f, 0.0000f, -53.3839f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( 29.8148f, 0.0000f, -123.4015f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 29.8147f, 0.0000f, -53.3839f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 54.8147f, 0.0000f, -53.3839f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 54.8148f, 0.0000f, -123.4015f);

		glTexCoord2f(0.0, 0.0);
		 glVertex3f( -4.2518f, 0.0000f, -193.4343f);
		glTexCoord2f(0.0, 1.0);
		 glVertex3f( 29.8148f, 0.0000f, -123.4015f);
		glTexCoord2f(1.0, 1.0);
		 glVertex3f( 54.8148f, 0.0000f, -123.4015f);
		glTexCoord2f(1.0, 0.0);
		 glVertex3f( 20.7482f, 0.0000f, -193.4343f);

		 glEnd();
	}
	else {
		currTrack.id++;
	}

	/*
	* Loading the object - car
	*/
	glTranslatef(initialx-sin(rotY),1,initialz-cos(rotY));
	glColor3f(1.0,0.23,0.27);
	glScalef(0.6,0.6,0.6);
	glRotatef(rotY, 0.0f, 1.0f, 0.0f);
	glCallList(ObjList);
	glRotatef(rotY, 0.0f, -1.0f, 0.0f);
	// glColor4f(0.0f, 0.0f, 0.0f, 0.0f);
	
	// glTranslatef(-(initialx-sin(rotY)),0,-(initialz-cos(rotY)));

	glPopMatrix();
	/*
	* Trying to do some HUD here
	*/
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	glOrtho(0.0, win.width, win.height, 0.0, -1.0, 10.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glDisable(GL_DEPTH_TEST);

	glClear(GL_DEPTH_BUFFER_BIT);

	glBegin(GL_QUADS);
		glColor3f(1.0f, 1.0f, 0.0f);
		glVertex2f(0.0, 0.0);
		glVertex2f(win.width, 0.0);
		glVertex2f(win.width, 100.0);
		glVertex2f(0.0, 100.0);
	glEnd();

	/*
	* Trying to write some stuff inside the HUD created.
	*/
	// char* myCharString = "Yo babes";
	// glutStrokeCharacter(GLUT_STROKE_ROMAN, 1/*myCharString*/);
	char quote[80];
	glScalef(0.4, 0.4, 0.5);
	glTranslatef(0.0f,150.0f, 0.0f);
	glRotatef(180, 1.0, 0.0, 0.0);
	sprintf(quote, "Speed = %.0f       Turn Angle=%.0f", -50*speed, turn);
    int lenghOfQuote = (int)strlen(quote);
    glPushMatrix();
    // glTranslatef(-(lenghOfQuote*37), -(l*200), 0.0);
    for (int i = 0; i < lenghOfQuote; i++)
    {
    	glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
        // glColor3f((UpwardsScrollVelocity/10)+300+(l*10),(UpwardsScrollVelocity/10)+300+(l*10),0.0);
        glutStrokeCharacter(GLUT_STROKE_ROMAN, quote[i]);
    }
    glPopMatrix();

	//Make sure we can render in 3d again
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	glutSwapBuffers();
}
/*!
	To set a valid raster position outside the viewport, first set a valid
    raster position inside the viewport, then call glBitmap with NULL
    as the bitmap parameter and with xmove and ymove set to
    the offsets of the new raster position. This technique is useful when
    panning an image around the viewport.
	(see http://www.opengl.org/sdk/docs/man/xhtml/glBitmap.xml and
	http://www.opengl.org/sdk/docs/man/xhtml/glDrawPixels.xml)
*/
void ImageView::GLDraw()
{	
#ifdef USE_OPEN_GL_WINDOW
	if (!valid())
		GLViewSetup();
#else
	gl_start();
#endif

	// Invert image
	//glPixelZoom(1.0f, -1.0f);
	glPixelZoom((float) m_scaling, (float) -m_scaling);

	// Set image origin
	glRasterPos2i(0, h());

	// Check that the raster position is valid
	GLboolean rasVal;

	glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &rasVal);

	if (!rasVal)
	{
		ShowError("Invalid raster position. No image will be shown");
	}

	// If image is scaled down, the view needs to be fully erased
	//if (m_zoom < 1)
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	
	m_mutex.Lock();

	if (m_curByteImage.is_contiguous() && m_curByteImage.size() > 0)
		glDrawPixels(m_curByteImage.ni(), m_curByteImage.nj(), GL_LUMINANCE,
			GL_UNSIGNED_BYTE, m_curByteImage.top_left_ptr());
	else if (m_curRGBImage.is_contiguous())
		glDrawPixels(m_curRGBImage.ni(), m_curRGBImage.nj(), GL_RGB,
			GL_UNSIGNED_BYTE, m_curRGBImage.top_left_ptr());
	else
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	m_mutex.Release();

	// Call the current vision system component (if there is one)
	// to draw over the current image
	if (m_pPainter)
	{
		glPushMatrix();
		glTranslated(m_offset.x, m_offset.y + h(), 0);
		glScaled(m_zoom, -m_zoom, 1);
		glColor4f(0, 0, 0, 1.0);
		m_pPainter->DrawWithMutex(m_painterInfo);
		glPopMatrix();
	}

#ifdef USE_OPEN_GL_WINDOW
	glFlush();
#else
	gl_finish();
#endif
}
//WinMain -- Main Window
int WINAPI WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR lpCmdLine, int nCmdShow )
{
    MSG msg;
    msg.message = WM_CREATE;

    WNDCLASS wc;
    wc.style = CS_HREDRAW|CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(GetModuleHandle(NULL), IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "chockngt";

    RegisterClass (&wc);

    // Create the window
    //mainWnd = CreateWindow (szAppName,szAppName,WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX,CW_USEDEFAULT,CW_USEDEFAULT,1024,600,0,0,hInstance,0);
    mainWnd = CreateWindow("chockngt","chockngt",WS_POPUP|WS_VISIBLE|WS_MAXIMIZE,0,0,0,0,0,0,hInstance,0);
    glInit();

    ShowWindow(mainWnd,SW_SHOW);
    UpdateWindow(mainWnd);

    // Initialize Swarm positions and stuff
    initSwarm();

    long startTime = timeGetTime();
    long lastTime = 0;

    // start music playback
    BASS_Init(-1,44100,0,mainWnd,NULL);
    mp3Str=BASS_StreamCreateFile(FALSE,"GT_muc.mp3",0,0,0);
    BASS_ChannelPlay(mp3Str, TRUE);
    BASS_Start();
    float fCurTime;
    GetAsyncKeyState(VK_ESCAPE);

    do
    {
        SetCursor(FALSE);

        while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
        {
            if (!IsDialogMessage(mainWnd, &msg))
            {
                TranslateMessage (&msg);
                DispatchMessage (&msg);
            }
        }
        if (msg.message == WM_QUIT) break; // early exit on quit

        // update timer
        long curTime = timeGetTime() - startTime;
        fCurTime = (float)curTime * 0.001f;
        long deltaTime = curTime - lastTime;
        float fDeltaTime = (float) deltaTime * 0.001f;
        lastTime = curTime;

        // render
        wglMakeCurrent(mainDC, mainRC);

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glDisable(GL_DEPTH_TEST);

        // draw background
        //drawQuad(-1.0f, 1.0f, -1.0f, 1.0f, 0.4f, 1.0f, 1.0f);
        glEnable(GL_DEPTH_TEST);

        // Distance to the center object
        // TODO: Hitchcock-effect by means of gluPerspective!
        float cameraDist = 20.0f;
        float cameraComeTime = 150.0f;
        if (fCurTime > cameraComeTime)
        {
            cameraDist = 3.0f + 17.0f / (1.0f + 0.1f * ((fCurTime - cameraComeTime) * (fCurTime - cameraComeTime)));
        }

        // set up matrices
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        // TODO aspect
        //gluPerspective(25.0,  1.8, 0.1, 100.0);
        gluPerspective(500.0f / cameraDist,  1.8, 0.1, 100.0);
        //gluPerspective(25.0,  1.8, 1.1, 100.0);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        //gluLookAt(0.0, 0.0, -cameraDist,
        //		  0.0, 0.0, 0.0,
        //		  0.0, 1.0, 0.0);
        gluLookAt(1., 0.5, -cameraDist,
                  1., 0.5, 0.0,
                  0.0, 1.0, 0.0);


        // lighting:
        float ambient[4] = {0.3f, 0.23f, 0.2f, 1.0f};
        //float diffuse[4] = {1.8f, 1.7f, 0.8f, 1.0f};
        float diffuse[4] = {0.9f, 0.85f, 0.4f, 1.0f};
        float diffuse2[4] = {0.45f, 0.475f, 0.2f, 1.0f};
        //float diffuse2[4] = {0.0f, 0.0f, 0.0f, 1.0f};
        float specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
        float lightDir[4] = {0.7f, 0.0f, 0.7f, 0.0f};
        float allOnes[4] = {1.0f, 1.0f, 1.0f, 1.0f};
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
        glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
        glLightfv(GL_LIGHT0, GL_POSITION, lightDir);
        //glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, allOnes);
        //glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, allOnes);
        //glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, allOnes);
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

        float metaAmount = 1.0f;
        int signedDistanceID = 1; // sphere
        if (fCurTime > 61.0f) signedDistanceID = 2; // metaballs
        //signedDistanceID = 0; // nothing

        int pathID = 0; // 8 moveTo points
        if (fCurTime > 80.0f)
        {
            pathID = 1; // 4 lines
            signedDistanceID = 0; // Nothing

            if (fCurTime > 130.0f)
            {
                pathID = 0; // 4 move to points
                signedDistanceID = 2; // metaballs
            }
        }

        // In reversed field
        if (fCurTime > 170.0f)
        {
            pathID = 0;
            signedDistanceID = 2;
            if (fCurTime > 190.0f)
            {
                pathID = 1;
                signedDistanceID = 0;
            }
            if (fCurTime > 210.0f)
            {
                pathID = 1;
                signedDistanceID = 2;
            }
            if (fCurTime > 217.0f)
            {
                pathID = 0;
                signedDistanceID = 1;
            }
        }

        // generate destiations
        float overshoot = 0.0f;
        if (fCurTime > 19.f)
        {
            float relTime = fCurTime - 19.f;
            overshoot = 2.0f * sin(relTime*0.17f) * (-cos(relTime * 0.75f) + 1.0f);
        }
        if (fCurTime > 200.0f)
        {
            float relTime = (fCurTime - 200.0f);
            overshoot /= relTime * relTime + 1.0f;
        }
        updateSwarmDestinations(pathID, fDeltaTime, overshoot);

        // update direction of the Triangles
        updateSwarmWithSignedDistance(signedDistanceID, fDeltaTime, metaAmount);

        // move all triangles
        moveSwarm(fDeltaTime);

        // Set how many triangles to render for each path
        int numTrisRender1 = (curTime - 11300) / 8;
        int numTrisRender2 = (curTime - 3300) / 2;
        numTrisRender1 = numTrisRender1 > NUM_TRIANGLES ? NUM_TRIANGLES : numTrisRender1;
        numTrisRender1 = numTrisRender1 < 0 ? 0 : numTrisRender1;
        numTrisRender2 = numTrisRender2 > NUM_TRIANGLES ? NUM_TRIANGLES : numTrisRender2;
        numTrisRender2 = numTrisRender2 < 0 ? 0 : numTrisRender2;
        float triBrightness = fCurTime / 30.0f + 0.2f;
        if (triBrightness > 1.0f) triBrightness = 1.0f;

        // render tris
        glBegin(GL_TRIANGLES);
        for (int i = 0; i < numTrisRender1; i++)
        {
            //glNormal3f(0.3f, 0.5f, 0.2f);
            float right[3];
            right[0] = tris.direction[i][1] * tris.normal[i][2] - tris.direction[i][2] * tris.normal[i][1];
            right[1] = tris.direction[i][2] * tris.normal[i][0] - tris.direction[i][0] * tris.normal[i][2];
            right[2] = tris.direction[i][0] * tris.normal[i][1] - tris.direction[i][1] * tris.normal[i][0];
            glNormal3fv(tris.normal[i]);
            glVertex3f(tris.position[i][0] + 0.2f * tris.direction[i][0], tris.position[i][1] + 0.2f * tris.direction[i][1], tris.position[i][2] + 0.2f * tris.direction[i][2]);
            glVertex3f(tris.position[i][0] + 0.2f * right[0], tris.position[i][1] + 0.2f * right[1], tris.position[i][2] + 0.2f * right[2]);
            glVertex3f(tris.position[i][0] - 0.2f * right[0], tris.position[i][1] - 0.2f * right[0], tris.position[i][2] - 0.2f * right[0]);
        }
        glEnd();

        glDepthMask(FALSE);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA,GL_ONE);
        glDisable(GL_LIGHTING);
        float beating = 1.0f - 0.25f * fabsf((float)sin(fCurTime*4.652f));
        glBegin(GL_TRIANGLES);
        for (int i = 0; i < numTrisRender2; i++)
        {
            const float colorA[3] = {0.3f, 0.5f, 1.0f};
            const float colorB[3] = {1.0f, 0.8f, 0.3f};
            const float colorC[3] = {2.0f, 0.4f, 0.1f};
            float color[3];
            float colorT = fCurTime * 0.01f;
            if (colorT > 1.0f) colorT = 1.0f;
            for (int c = 0; c < 3; c++)
            {
                color[c] = colorA[c] * (1.0f - colorT) + colorT * colorB[c];
            }
            if (fCurTime > 100.0f)
            {
                colorT = (fCurTime - 100.0f) * 0.1f - ((i*i*17)%63) * 0.1f;
                if (colorT < 0.0f) colorT = 0.0f;
                if (colorT > 1.0f) colorT = 1.0f;
                for (int c = 0; c < 3; c++)
                {
                    color[c] = colorB[c] * (1.0f - colorT) + colorT * colorC[c];
                }
            }
            // Some color noise
            for (int c = 0; c < 3; c++)
            {
                float n = ((((i*i+13)*(c*c+7)+(i*(c+1))) % 100) - 50) * 0.0025f;
                color[c] += n;
            }

            //glNormal3f(0.3f, 0.5f, 0.2f);
            glColor4f(color[0], color[1], color[2], beating * 0.1f * triBrightness);
            float right[3];
            right[0] = tris.direction[i][1] * tris.normal[i][2] - tris.direction[i][2] * tris.normal[i][1];
            right[1] = tris.direction[i][2] * tris.normal[i][0] - tris.direction[i][0] * tris.normal[i][2];
            right[2] = tris.direction[i][0] * tris.normal[i][1] - tris.direction[i][1] * tris.normal[i][0];
            glNormal3fv(tris.normal[i]);
            glVertex3f(tris.position[i][0] + 0.6f * tris.direction[i][0],
                       tris.position[i][1] + 0.6f * tris.direction[i][1],
                       tris.position[i][2] + 0.6f * tris.direction[i][2] - 0.1f);
            glVertex3f(tris.position[i][0] + 0.6f * right[0] - 0.2f * tris.direction[i][0],
                       tris.position[i][1] + 0.6f * right[1] - 0.2f * tris.direction[i][1],
                       tris.position[i][2] + 0.6f * right[2] - 0.2f * tris.direction[i][2] - 0.001f);
            glVertex3f(tris.position[i][0] - 0.6f * right[0] - 0.2f * tris.direction[i][0],
                       tris.position[i][1] - 0.6f * right[0] - 0.2f * tris.direction[i][1],
                       tris.position[i][2] - 0.6f * right[0] - 0.2f * tris.direction[i][2] - 0.001f);
        }
        glEnd();
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glDisable(GL_DEPTH_TEST);
        glBegin(GL_TRIANGLES);
        if (fCurTime > 219.0f)
        {
            float alpha = (fCurTime - 219.0f) * 0.5f;
            alpha = alpha > 1.0f ? 1.0f : alpha;
            glColor4f(0.0f, 0.0f, 0.0f, alpha);
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            glVertex3f(-180.0f, 180.0f, 1.0f);
            glVertex3f(180.0f, 0.0f, 1.0f);
            glVertex3f(-180.0f, -180.0f, 1.0f);
        }
        glEnd();
        glDepthMask(TRUE);

        // draw credits
        if (fCurTime > 221.0f)
        {
            float alpha = (fCurTime - 221.0f) * 1.0f;
            alpha = alpha > 1.0f ? 1.0f : alpha;
            drawQuad(-1.3f, 0.7f, -0.1f, 0.4f, 0.0f, 0.175f, alpha);
            drawQuad(-0.7f, 1.3f, -0.5f, 0.0f, 0.175f, 0.35f, alpha);
        }

        glEnable(GL_DEPTH_TEST);
        glDisable(GL_BLEND);


        //glColor3ub(200, 100, 50);
        //glEnable(GL_BLEND);
        //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // swap buffers
        wglSwapLayerBuffers(mainDC, WGL_SWAP_MAIN_PLANE);

        //Sleep(5);
    } while (msg.message != WM_QUIT && fCurTime < 230.0f && !GetAsyncKeyState(VK_ESCAPE));

    // music uninit
    BASS_ChannelStop(mp3Str);
    BASS_StreamFree(mp3Str);
    BASS_Free();

    glUnInit();

    return msg.wParam;
}
void GLStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const
{
  CHECK_FOR_ERROR;

  glPushAttrib(GL_COLOR_BUFFER_BIT);
  Stroke::MediumType strokeType = iStrokeRep->getMediumType();
  // int averageTextureAlpha=0.5; //default value
  // if (strokeType==OIL_STROKE)
    // averageTextureAlpha=0.75; 
  // if (strokeType>=NO_BLEND_STROKE)
    // averageTextureAlpha=1.0; 
  // if (strokeType<0)
    // {
      // renderNoTexture(iStrokeRep);
      // return;
    // }
  int i;
  glDisable(GL_CULL_FACE);
  glDisable(GL_LIGHTING);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  glShadeModel(GL_SMOOTH);
  glDisable(GL_DEPTH_TEST);
    
  glEnable(GL_BLEND);
  //  glDisable(GL_BLEND);

  if(strokeType==Stroke::DRY_MEDIUM)
    {
      glBlendEquation(GL_MIN);  //changed this from GL_MAX in order to work for a black background image instead of white
    }
  else if(strokeType==Stroke::OPAQUE_MEDIUM || strokeType==Stroke::DRY_MEDIUM)
    {
      glBlendEquation(GL_FUNC_ADD);
      //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      //      glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_REVERSE_SUBTRACT);
      glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
			  GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    }
  else
    {
            glBlendEquation(GL_FUNC_ADD);
      //      glBlendFunc(GL_SRC_ALPHA, GL_ONE);

      //      glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_SUBTRACT);
      glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE,
			  GL_ONE_MINUS_SRC_ALPHA, GL_ONE);

      //      printf("using opaque\n");
    }


  //  glBlendFunc(GL_ONE, GL_ZERO);

  //  glDisable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
  //glDisable(GL_BLEND);
  //  glDisable(GL_TEXTURE_1D);
  glEnable(GL_TEXTURE_2D);


  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

  //first texture, basically the only one for lighter strokes
  glBindTexture(GL_TEXTURE_2D, iStrokeRep->getTextureId()); 
  //glBindTexture(GL_TEXTURE_2D, _textureManager.getPaperTextureIndex()); 


  // TODO:   READ BACK PIXEL TRANSFER, PIXEL MAP, MATRICES, ETC.
  /*
  // loop over transfer functions and print out glIsEnabled()
  GLenum funcs[] = { GL_TEXTURE_1D,
                     GL_INDEX_LOGIC_OP, 
                     GL_COLOR_LOGIC_OP,
		     GL_COLOR_MATERIAL,
		     GL_COLOR_SUM,
		     GL_COLOR_TABLE,
		     GL_CONVOLUTION_1D,
		     GL_CONVOLUTION_2D,
		     GL_INDEX_LOGIC_OP,
		     GL_MAP1_COLOR_4,
		     GL_MAP1_INDEX,
		     GL_MAP1_TEXTURE_COORD_1,
		     GL_MAP1_TEXTURE_COORD_2,
		     GL_MAP1_TEXTURE_COORD_3,
		     GL_MAP1_TEXTURE_COORD_4,
		     GL_MAP2_INDEX,
		     GL_POST_COLOR_MATRIX_COLOR_TABLE,
		     GL_POST_CONVOLUTION_COLOR_TABLE,
		     GL_SEPARABLE_2D };
  for(int i =0; i<17;i++)
    printf("[(%d) %0X: %s]\n", i, funcs[i], (glIsEnabled(funcs[i]) ? "ENABLED" : "disabled"));

  
  GLfloat cmat[16];
  glGetFloatv(GL_COLOR_MATRIX, cmat);
  printf("color matrix: %f %f %f %f; %f %f %f %f; %f %f %f %f; %f %f %f %f\n",
	 cmat[0], cmat[1], cmat[2], cmat[3], cmat[4],cmat[5], cmat[6], cmat[7], cmat[8],
	 cmat[9], cmat[10], cmat[11], cmat[12], cmat[13], cmat[14], cmat[15]);*/


  //      static bool printed = false;

  //      if (!printed)
  //{
	  //	  printf("first point:(%f, %f) ",svRep->point2d()[0], svRep->point2d()[1]);
	  /*
	  printf("glstrokerenderer: (outputWidth = %d, outputHeight = %d)\n", outputWidth, outputHeight);
	  double matrix[16];
	  glGetDoublev(GL_MODELVIEW_MATRIX, matrix);
	  printf("Modelview= [%f %f %f %f; %f %f %f %f; %f %f %f %f; %f %f %f %f]'\n", 
		 matrix[0], matrix[1], matrix[2], matrix[3],matrix[4],matrix[5],matrix[6],matrix[7],matrix[8],matrix[9], 
		 matrix[10],matrix[11],matrix[12],matrix[13],matrix[14],matrix[15]);  
	  glGetDoublev(GL_PROJECTION_MATRIX, matrix);
	  printf("Projection= [%f %f %f %f; %f %f %f %f; %f %f %f %f; %f %f %f %f]'\n", 
		 matrix[0], matrix[1], matrix[2], matrix[3],matrix[4],matrix[5],matrix[6],matrix[7],matrix[8],matrix[9], 
		 matrix[10],matrix[11],matrix[12],matrix[13],matrix[14],matrix[15]);

	  double viewp[4];
	  glGetDoublev(GL_VIEWPORT, viewp);
	  printf("GL1: Viewport = [%f %f %f %f]\n", viewp[0], viewp[1], viewp[2], viewp[3]);
	  */



	  //	  printed = true;
  //	}
      /*
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_BLEND);

  glColor4f(1,.5,.2,.5);
  glBegin(GL_TRIANGLES);
  glVertex2f(0,0);
  glVertex2f(100,50);
  glVertex2f(50,100);
  glEnd();
  
  glEnable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
      */

      //  glViewport(0,0,outputWidth, outputHeight);
  
  vector<Strip*>& strips = iStrokeRep->getStrips();
  for(vector<Strip*>::iterator s=strips.begin(), send=strips.end();
  s!=send;
  ++s){
    Strip::vertex_container& vertices = (*s)->vertices();



    glBegin(GL_TRIANGLE_STRIP);
    for(Strip::vertex_container::iterator v=vertices.begin(), vend=vertices.end();
    v!=vend;
    ++v){
      StrokeVertexRep * svRep = (*v);
      Vec3r color = svRep->color();
      real alpha = svRep->alpha();
      glColor4f(complementColor(color[0]), complementColor(color[1]), 
      		complementColor(color[2]), alpha);
      //      glColor4f(1,0,0,1);
      
      static bool printed2 = false;
      /*
      if (!printed2)
	{
	  printf("first point: (%f, %f)\n", svRep->point2d()[0], svRep->point2d()[1]);
	  printed2 =true;
	}
      */

      glTexCoord2f(svRep->texCoord()[0],svRep->texCoord()[1] );
      glVertex2f(svRep->point2d()[0], svRep->point2d()[1]);
    }  
    glEnd();
  }
//  if (strokeType>=NO_BLEND_STROKE) return;
  //  //return;
  //
  //  //second texture, the complement, for stronger strokes
  //  glBindTexture(GL_TEXTURE_2D, _textureManager.getTextureIndex(2*strokeType+1)); 
  //  glBegin(GL_TRIANGLE_STRIP);
  //  for(i=0; i<_sizeStrip; i++)
  //  {
  //    glColor4f(complementColor(_color[i][0]), 
  //      complementColor(_color[i][1]), 
  //      complementColor(_color[i][2]), _alpha[i]);
  //    glTexCoord2f(_texCoord[i][0],_texCoord[i][1] );
  //    glVertex2f(_vertex[i][0], _vertex[i][1]);
  //  }
  //  glEnd();

  /*
	  double viewp[4];
	  glGetDoublev(GL_VIEWPORT, viewp);
	  printf("GL2: Viewport = [%f %f %f %f]\n", viewp[0], viewp[1], viewp[2], viewp[3]);
  */

  glPopAttrib();

  CHECK_FOR_ERROR;
}
//--------------------------------------------------------------
void testApp::draw(){
	glPushMatrix();
	
	glTranslatef(ofGetWidth()/2, 0, 0);
	glRotatef(currentRot, 0, 1, 0);
	
	ofSetColor(255);
	
	glEnable(GL_DEPTH_TEST);
	glPointSize(pointSize);
	
	if(useTexture) image.getTextureReference().bind();		// new in OF006
	if(useSprite) {
		glEnable(GL_POINT_SPRITE);
		glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
	}	
	
    switch(drawMode) {
        case kModeVA:
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_COLOR_ARRAY);
            
            glVertexPointer(3, GL_FLOAT, 0, pos);
            glColorPointer(4, GL_FLOAT, 0, col);
            
            glDrawArrays(GL_POINTS, 0, numParticles);
            
            glDisableClientState(GL_VERTEX_ARRAY); 
            glDisableClientState(GL_COLOR_ARRAY);
            break;
            
        case kModeVBO:
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_COLOR_ARRAY);
            
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[0]);
            glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, numParticles * 3 * sizeof(float), pos);
            glVertexPointer(3, GL_FLOAT, 0, 0);
            
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[1]);
            glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, numParticles * 4 * sizeof(float), col);
            glColorPointer(4, GL_FLOAT, 0, 0);
            
            
            glDrawArrays(GL_POINTS, 0, numParticles);
            
            glDisableClientState(GL_VERTEX_ARRAY); 
            glDisableClientState(GL_COLOR_ARRAY);
            
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
            break;
            
        case kModeNormal:
        default:
            glBegin(GL_POINTS);
            for(int i=0; i<numParticles; i++) {
                glColor4f(col[i][0], col[i][1], col[i][2], col[i][3]);
                glVertex3f(pos[i][0], pos[i][1], pos[i][2]);
            }
            glEnd();
	}
	
	if(useTexture) image.getTextureReference().unbind();		// new in OF006
	
	if(useSprite) {
		glDisable(GL_POINT_SPRITE);
	}
	
	glDisable(GL_DEPTH_TEST);	
	glPopMatrix();
    
    // black rectangle for text
	ofSetColor(0);
	ofRect(0, 0, 200, 200);
    
	ofSetColor(255);
	ofDrawBitmapString("FPS: " + ofToString(ofGetFrameRate(), 2) + "\n" + 
					   "numParticles: " + ofToString(numParticles) + "\n" + 
                       "immediate mode (1): " + (drawMode == kModeNormal ? "X" : "") + "\n" + 
                       "useVA (2): " + (drawMode == kModeVA ? "X" : "") + "\n" + 
                       "useVBO (3): " + (drawMode == kModeVBO ? "X" : "") + "\n" + 
                       "useTexture (t): " + (useTexture ? "X" : "") + "\n" + 
                       "useSprite (s): " + (useSprite ? "X" : "") + "\n" + 
                       "vsync (v): " + (vsync ? "X" : "") + "\n" + 
                       "pointSize []: " + ofToString(pointSize)
                       
                       , 20, 20);
}
// ----------------------------------------------------------
// display() Callback function
// ----------------------------------------------------------
void display(){
    
    
    
    //  Clear screen and Z-buffer
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    
    // Reset transformations
    glLoadIdentity();
    
    glRotatef( rotate_x, 1.0, 0.0, 0.0 );
    glRotatef( rotate_y, 0.0, 1.0, 0.0 );
    
    // side - BACK
    glBegin(GL_POLYGON);
    glColor4f(   1.0,  1.0, 1.0, 1.0);
    glVertex3f(  0.5, -0.5, 0.5 );
    glVertex3f(  0.5,  0.5, 0.5 );
    glVertex3f( -0.5,  0.5, 0.5 );
    glVertex3f( -0.5, -0.5, 0.5 );
    glEnd();
    
    
    
    // side - LEFT
    glBegin(GL_POLYGON);
    glColor4f(   0.85,  0.85,  0.85, 0.75 );
    glVertex3f( -0.5, -0.5,  0.5 );
    glVertex3f( -0.5,  0.5,  0.5 );
    glVertex3f( -0.5,  0.5, -0.5 );
    glVertex3f( -0.5, -0.5, -0.5 );
    glEnd();
    
    
    // side - BOTTOM
    glBegin(GL_POLYGON);
    glColor4f(   0.75,  0.75,  0.75, 1.0 );
    glVertex3f(  0.5, -0.5, -0.5 );
    glVertex3f(  0.5, -0.5,  0.5 );
    glVertex3f( -0.5, -0.5,  0.5 );
    glVertex3f( -0.5, -0.5, -0.5 );
    glEnd();
    
    
    //Sample Curevs in the coordinates
    SampleCurves();
    
    //lable units to the axis
    lables_slot();
    lable_curve_Occurrence();
    
    
    
    glBegin(GL_POLYGON);
    glColor4f(   0.8,  0.8,  0.8, 0.25 );
    glVertex3f( -0.25, -0.5,  0.5 );
    glVertex3f( -0.25,  0.5,  0.5 );
    glVertex3f( -0.25,  0.5, -0.5 );
    glVertex3f( -0.25, -0.5, -0.5 );
    glEnd();
    
    glBegin(GL_POLYGON);
    glColor4f(   0.8,  0.8,  0.8, 0.25 );
    glVertex3f( 0, -0.5,  0.5 );
    glVertex3f( 0,  0.5,  0.5 );
    glVertex3f( 0,  0.5, -0.5 );
    glVertex3f( 0, -0.5, -0.5 );
    glEnd();
    
    glBegin(GL_POLYGON);
    glColor4f(   0.8,  0.8,  0.8, 0.25 );
    glVertex3f( 0.25, -0.5,  0.5 );
    glVertex3f( 0.25,  0.5,  0.5 );
    glVertex3f( 0.25,  0.5, -0.5 );
    glVertex3f( 0.25, -0.5, -0.5 );
    glEnd();
    
    glBegin(GL_POLYGON);
    glColor4f(   0.8,  0.8,  0.8, 0.25 );
    glVertex3f( 0.5, -0.5,  0.5 );
    glVertex3f( 0.5,  0.5,  0.5 );
    glVertex3f( 0.5,  0.5, -0.5 );
    glVertex3f( 0.5, -0.5, -0.5 );
    glEnd();
    
    glBegin(GL_LINES);
    glColor3f (0.1, 0.1, 0.1);
    glVertex3f( 0,  0.5,  -0.5 );
    glVertex3f( 0, -0.5,  -0.5 );
    glEnd();
    
    glBegin(GL_LINES);
    glVertex3f( -0.5, -0.5,  -0.5 );
    glVertex3f( -0.5,  0.5,  -0.5 );
    glEnd();
    
    glBegin(GL_LINES);
    glVertex3f(  0.5, -0.5,  -0.5 );
    glVertex3f(  0.5,  0.5,  -0.5 );
    glEnd();
    
    glBegin(GL_LINES);
    glVertex3f( -0.25, -0.5,  -0.5 );
    glVertex3f( -0.25,  0.5,  -0.5 );
    glEnd();
    
    glBegin(GL_LINES);
    glColor3f (0.1, 0.1, 0.1);
    glVertex3f(  0.25,  0.5,  -0.5 );
    glVertex3f(  0.25, -0.5,  -0.5 );
    glEnd();
    
    
    glFlush();
    glutSwapBuffers();
    
}
Exemple #11
0
void display(UGWindow uwin)
{
   int i;

   glClear (GL_COLOR_BUFFER_BIT);

/* select white for all lines  */
   glColor4f (1.0, 1.0, 1.0, 1.0);

/* in 1st row, 3 lines, each with a different stipple  */
   //glEnable (GL_LINE_STIPPLE);
   
   //glLineStipple (1, 0x0101);  /*  dotted  */
   glColor4f(1., 0., 0., 1.);
   drawOneLine (50.0, 125.0, 150.0, 125.0);
   //glLineStipple (1, 0x00FF);  /*  dashed  */
   glColor4f(0., 1., 0., 1.);
   drawOneLine (150.0, 125.0, 250.0, 125.0);
   //glLineStipple (1, 0x1C47);  /*  dash/dot/dash  */
   glColor4f(0., 0., 1., 1.);
   drawOneLine (250.0, 125.0, 350.0, 125.0);

   glColor4f(1., 1., 1., 1.);
/* in 2nd row, 3 wide lines, each with different stipple */
   glLineWidth (5.0);
   //glLineStipple (1, 0x0101);  /*  dotted  */
   drawOneLine (50.0, 100.0, 150.0, 100.0);
   //glLineStipple (1, 0x00FF);  /*  dashed  */
   glColor4f(1., 1., 0., 1.);
   drawOneLine (150.0, 100.0, 250.0, 100.0);
   //glLineStipple (1, 0x1C47);  /*  dash/dot/dash  */
   glColor4f(0., 1., 1., 1.);
   drawOneLine (250.0, 100.0, 350.0, 100.0);
   glLineWidth (1.0);
   glColor4f(1., 0., 1., 1.);

/* in 3rd row, 6 lines, with dash/dot/dash stipple  */
/* as part of a single connected line strip         */
   //glLineStipple (1, 0x1C47);  /*  dash/dot/dash  */
#if 0
   glBegin (GL_LINE_STRIP);
   for (i = 0; i < 7; i++)
      glVertex2f (50.0 + ((GLfloat) i * 50.0), 75.0);
   glEnd ();
#else
   {
   GLfloat v[14];
   for (i = 0; i < 7; i++) {
      v[2*i] = 50.0 + ((GLfloat) i * 50.0); v[2*i+1] = 75.0;
   }
   glVertexPointer(2, GL_FLOAT, 0, v);
   glEnableClientState(GL_VERTEX_ARRAY);
   glDrawArrays(GL_LINE_STRIP, 0, 7);
   }
#endif

   glColor4f(1., 1., 1., 1.);
/* in 4th row, 6 independent lines with same stipple  */
   for (i = 0; i < 6; i++) {
      drawOneLine (50.0 + ((GLfloat) i * 50.0), 50.0,
         50.0 + ((GLfloat)(i+1) * 50.0), 50.0);
   }

   glColor4f(.8, .8, .8, 1.);
/* in 5th row, 1 line, with dash/dot/dash stipple    */
/* and a stipple repeat factor of 5                  */
   //glLineStipple (5, 0x1C47);  /*  dash/dot/dash  */
   drawOneLine (50.0, 25.0, 350.0, 25.0);

   //glDisable (GL_LINE_STIPPLE);
   glFlush ();
   ugSwapBuffers(uwin);
}
Exemple #12
0
void glColor(ColorARGB color)
{
	glColor4f(color.GetRed()/255.0f, color.GetGreen()/255.0f, color.GetBlue()/255.0f, color.GetAlpha()/255.0f);
}
Exemple #13
0
/* Draw given image buffer on a screen using GLSL for display transform */
void glaDrawImBuf_glsl_clipping(ImBuf *ibuf, float x, float y, int zoomfilter,
                                ColorManagedViewSettings *view_settings,
                                ColorManagedDisplaySettings *display_settings,
                                float clip_min_x, float clip_min_y,
                                float clip_max_x, float clip_max_y)
{
	bool force_fallback = false;
	bool need_fallback = true;

	/* Early out */
	if (ibuf->rect == NULL && ibuf->rect_float == NULL)
		return;

	/* Single channel images could not be transformed using GLSL yet */
	force_fallback |= ibuf->channels == 1;

	/* If user decided not to use GLSL, fallback to glaDrawPixelsAuto */
	force_fallback |= (U.image_draw_method != IMAGE_DRAW_METHOD_GLSL);

	/* Try to draw buffer using GLSL display transform */
	if (force_fallback == false) {
		int ok;

		if (ibuf->rect_float) {
			if (ibuf->float_colorspace) {
				ok = IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
				                                                    ibuf->float_colorspace,
				                                                    ibuf->dither, true);
			}
			else {
				ok = IMB_colormanagement_setup_glsl_draw(view_settings, display_settings,
				                                         ibuf->dither, true);
			}
		}
		else {
			ok = IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
			                                                    ibuf->rect_colorspace,
			                                                    ibuf->dither, false);
		}

		if (ok) {
			glColor4f(1.0, 1.0, 1.0, 1.0);

			if (ibuf->rect_float) {
				int format = 0;

				if (ibuf->channels == 3)
					format = GL_RGB;
				else if (ibuf->channels == 4)
					format = GL_RGBA;
				else
					BLI_assert(!"Incompatible number of channels for GLSL display");

				if (format != 0) {
					glaDrawPixelsTex_clipping(x, y, ibuf->x, ibuf->y, format, GL_FLOAT,
					                          zoomfilter, ibuf->rect_float,
					                          clip_min_x, clip_min_y, clip_max_x, clip_max_y);
				}
			}
			else if (ibuf->rect) {
				/* ibuf->rect is always RGBA */
				glaDrawPixelsTex_clipping(x, y, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE,
				                          zoomfilter, ibuf->rect,
				                          clip_min_x, clip_min_y, clip_max_x, clip_max_y);
			}

			IMB_colormanagement_finish_glsl_draw();

			need_fallback = false;
		}
	}

	/* In case GLSL failed or not usable, fallback to glaDrawPixelsAuto */
	if (need_fallback) {
		unsigned char *display_buffer;
		void *cache_handle;

		display_buffer = IMB_display_buffer_acquire(ibuf, view_settings, display_settings, &cache_handle);

		if (display_buffer) {
			glaDrawPixelsAuto_clipping(x, y, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE,
			                           zoomfilter, display_buffer,
			                           clip_min_x, clip_min_y, clip_max_x, clip_max_y);
		}

		IMB_display_buffer_release(cache_handle);
	}
}
Exemple #14
0
void Cube3DOverlay::render(RenderArgs* args) {
    if (!_visible) {
        return; // do nothing if we're not visible
    }


    float glowLevel = getGlowLevel();
    Glower* glower = NULL;
    if (glowLevel > 0.0f) {
        glower = new Glower(glowLevel);
    }

    float alpha = getAlpha();
    xColor color = getColor();
    const float MAX_COLOR = 255.0f;
    glColor4f(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);

    //glDisable(GL_LIGHTING);

    // TODO: handle registration point??    
    glm::vec3 position = getPosition();
    glm::vec3 center = getCenter();
    glm::vec3 dimensions = getDimensions();
    glm::quat rotation = getRotation();
    
    glPushMatrix();
        glTranslatef(position.x, position.y, position.z);
        glm::vec3 axis = glm::axis(rotation);
        glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
        glPushMatrix();
            glm::vec3 positionToCenter = center - position;
            glTranslatef(positionToCenter.x, positionToCenter.y, positionToCenter.z);
            if (_isSolid) {
                if (_borderSize > 0) {
                    // Draw a cube at a larger size behind the main cube, creating
                    // a border effect.
                    // Disable writing to the depth mask so that the "border" cube will not
                    // occlude the main cube.  This means the border could be covered by
                    // overlays that are further back and drawn later, but this is good
                    // enough for the use-case.
                    glDepthMask(GL_FALSE);
                    glPushMatrix();
                        glColor4f(1.0f, 1.0f, 1.0f, alpha);
                        glScalef(dimensions.x * _borderSize, dimensions.y * _borderSize, dimensions.z * _borderSize);
                        Application::getInstance()->getDeferredLightingEffect()->renderSolidCube(1.0f);
                    glPopMatrix();
                    glDepthMask(GL_TRUE);
                }

                glPushMatrix();
                    glColor4f(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
                    glScalef(dimensions.x, dimensions.y, dimensions.z);
                    Application::getInstance()->getDeferredLightingEffect()->renderSolidCube(1.0f);
                glPopMatrix();
            } else {
                glLineWidth(_lineWidth);

                if (getIsDashedLine()) {
                    glm::vec3 halfDimensions = dimensions / 2.0f;
                    glm::vec3 bottomLeftNear(-halfDimensions.x, -halfDimensions.y, -halfDimensions.z);
                    glm::vec3 bottomRightNear(halfDimensions.x, -halfDimensions.y, -halfDimensions.z);
                    glm::vec3 topLeftNear(-halfDimensions.x, halfDimensions.y, -halfDimensions.z);
                    glm::vec3 topRightNear(halfDimensions.x, halfDimensions.y, -halfDimensions.z);

                    glm::vec3 bottomLeftFar(-halfDimensions.x, -halfDimensions.y, halfDimensions.z);
                    glm::vec3 bottomRightFar(halfDimensions.x, -halfDimensions.y, halfDimensions.z);
                    glm::vec3 topLeftFar(-halfDimensions.x, halfDimensions.y, halfDimensions.z);
                    glm::vec3 topRightFar(halfDimensions.x, halfDimensions.y, halfDimensions.z);
                
                    drawDashedLine(bottomLeftNear, bottomRightNear);
                    drawDashedLine(bottomRightNear, bottomRightFar);
                    drawDashedLine(bottomRightFar, bottomLeftFar);
                    drawDashedLine(bottomLeftFar, bottomLeftNear);

                    drawDashedLine(topLeftNear, topRightNear);
                    drawDashedLine(topRightNear, topRightFar);
                    drawDashedLine(topRightFar, topLeftFar);
                    drawDashedLine(topLeftFar, topLeftNear);

                    drawDashedLine(bottomLeftNear, topLeftNear);
                    drawDashedLine(bottomRightNear, topRightNear);
                    drawDashedLine(bottomLeftFar, topLeftFar);
                    drawDashedLine(bottomRightFar, topRightFar);

                } else {
                    glScalef(dimensions.x, dimensions.y, dimensions.z);
                    Application::getInstance()->getDeferredLightingEffect()->renderWireCube(1.0f);
                }
            }
        glPopMatrix();
    glPopMatrix();

    if (glower) {
        delete glower;
    }
}
void Particle::Render(Camera* camera, unsigned int i, bool drawAxes)
{
    switch( this->_type )
    {
    case BillBoard:
        break;
    case VectorAligned:
        break;
    case ScreenFacing:
    default:
    {
        Vector3f particleToCamera = camera->GetPosition()-this->_position;
        this->_depth = particleToCamera.Length();

        Vector3f cameraYAxis = camera->GetEulerRotation()*Vector3f(sin(this->_rotation), cos(this->_rotation), 0.0f);
        Vector3f localX = cameraYAxis.Cross(particleToCamera);
        Vector3f localY = particleToCamera.Cross(localX);

        localX.Normalize();
        localY.Normalize();

        // Set blend mode
        switch( this->_blendMode )
        {
        case Subtractive:
            glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE);
            break;
        case Additive:
            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
            break;
        case Normal:
        default:
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            break;
        }

        // Evaluate animators
        float t = 1.0f-this->_life/this->_maxLife;

        Vector2f size = this->_size->GetValue(t);

        // Bind texture
        if( this->_texture )
        {
            glBindTexture(GL_TEXTURE_2D, this->_texture->GetTextureName());
        }

        // Render
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
        glBegin(GL_QUADS);

        glColor4f(this->_color.r, this->_color.g, this->_color.b, this->_color.a);

        // TODO (Viet Nguyen): Get rid of texture coordinate hacks!!!!

        glTexCoord2f(0.0f, 0.0f);
        glVertex3fv((float*)
                    (this->_position+(-localX)*size.width+(-localY)*size.height));

        glTexCoord2f(1.0f/4.0f/*!!!!*/, 0.0f);
        glVertex3fv((float*)
                    (this->_position+localX*size.width+(-localY)*size.height));

        glTexCoord2f(1.0f/4.0f/*!!!!*/, 1.0f);
        glVertex3fv((float*)
                    (this->_position+localX*size.width+localY*size.height));

        glTexCoord2f(0.0f, 1.0f);
        glVertex3fv((float*)
                    (this->_position+(-localX)*size.width+localY*size.height));

        glEnd();

        // Unbind texture
        if( this->_texture)
        {
            glBindTexture(GL_TEXTURE_2D, 0);
        }

        if( drawAxes )
        {
            glBegin(GL_LINES);
            glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

            glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
            glVertex3fv((float*)(this->_position));
            glVertex3fv((float*)(this->_position+localX*size.width));

            glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
            glVertex3fv((float*)(this->_position));
            glVertex3fv((float*)(this->_position+localY*size.height));

            glEnd();
        }
    }
    }
}
void CBuilderCAI::DrawCommands(void)
{
	if(uh->limitDgun && owner->unitDef->isCommander) {
		glColor4f(1.0f, 1.0f, 1.0f, 0.6f);
		glSurfaceCircle(gs->Team(owner->team)->startPos, uh->dgunRadius, 40);
	}

	lineDrawer.StartPath(owner->midPos, cmdColors.start);

	if (owner->selfDCountdown != 0) {
		lineDrawer.DrawIconAtLastPos(CMD_SELFD);
	}

	CCommandQueue::iterator ci;
	for (ci = commandQue.begin(); ci != commandQue.end(); ++ci) {
		switch(ci->id) {
			case CMD_MOVE: {
				const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
				lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.move);
				break;
			}
			case CMD_FIGHT:{
				const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
				lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.fight);
				break;
			}
			case CMD_PATROL: {
				const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
				lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.patrol);
				break;
			}
			case CMD_GUARD: {
				const CUnit* unit = uh->units[int(ci->params[0])];
				if((unit != NULL) && isTrackable(unit)) {
					const float3 endPos =
						helper->GetUnitErrorPos(unit, owner->allyteam);
					lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.guard);
				}
				break;
			}
			case CMD_RESTORE: {
				const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
				lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.restore);
				lineDrawer.Break(endPos, cmdColors.restore);
				glSurfaceCircle(endPos, ci->params[3], 20);
				lineDrawer.RestartSameColor();
				break;
			}
			case CMD_ATTACK:
			case CMD_DGUN: {
				if (ci->params.size() == 1) {
					const CUnit* unit = uh->units[int(ci->params[0])];
					if((unit != NULL) && isTrackable(unit)) {
						const float3 endPos =
						  helper->GetUnitErrorPos(unit, owner->allyteam);
						lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.attack);
					}
				} else {
					const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
					lineDrawer.DrawLineAndIcon(ci->id, endPos, cmdColors.attack);
				}
				break;
			}
			case CMD_RECLAIM:
			case CMD_RESURRECT: {
				const float* color = (ci->id == CMD_RECLAIM) ? cmdColors.reclaim
				                                             : cmdColors.resurrect;
				if (ci->params.size() == 4) {
					const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
					lineDrawer.DrawLineAndIcon(ci->id, endPos, color);
					lineDrawer.Break(endPos, color);
					glSurfaceCircle(endPos, ci->params[3], 20);
					lineDrawer.RestartSameColor();
				} else {
					int id = (int)ci->params[0];
					if (id >= MAX_UNITS) {
						CFeatureSet::iterator it = featureHandler->activeFeatures.find(id - MAX_UNITS);
						if (it != featureHandler->activeFeatures.end()) {
							const float3 endPos = (*it)->midPos;
							lineDrawer.DrawLineAndIcon(ci->id, endPos, color);
						}
					} else {
						const CUnit* unit = uh->units[id];
						if((unit != NULL) && (unit != owner) && isTrackable(unit)) {
							const float3 endPos =
								helper->GetUnitErrorPos(unit, owner->allyteam);
							lineDrawer.DrawLineAndIcon(ci->id, endPos, color);
						}
					}
				}
				break;
			}
			case CMD_REPAIR:
			case CMD_CAPTURE: {
				const float* color = (ci->id == CMD_REPAIR) ? cmdColors.repair
				                                            : cmdColors.capture;
				if (ci->params.size() == 4) {
					const float3 endPos(ci->params[0], ci->params[1], ci->params[2]);
					lineDrawer.DrawLineAndIcon(ci->id, endPos, color);
					lineDrawer.Break(endPos, color);
					glSurfaceCircle(endPos, ci->params[3], 20);
					lineDrawer.RestartSameColor();
				} else {
					const CUnit* unit = uh->units[int(ci->params[0])];
					if((unit != NULL) && isTrackable(unit)) {
						const float3 endPos =
							helper->GetUnitErrorPos(unit, owner->allyteam);
						lineDrawer.DrawLineAndIcon(ci->id, endPos, color);
					}
				}
				break;
			}
			case CMD_LOAD_ONTO:{
				const CUnit* unit = uh->units[int(ci->params[0])];
				lineDrawer.DrawLineAndIcon(ci->id, unit->pos, cmdColors.load);
				break;
			}
			case CMD_WAIT:{
				DrawWaitIcon(*ci);
				break;
			}
			case CMD_SELFD:{
				lineDrawer.DrawIconAtLastPos(ci->id);
				break;
			}
		}

		if (ci->id < 0) {
			map<int, string>::const_iterator boi = buildOptions.find(ci->id);
			if (boi != buildOptions.end()) {
				BuildInfo bi;
				bi.def = unitDefHandler->GetUnitByID(-(ci->id));
				if (ci->params.size() == 4) {
					bi.buildFacing = int(ci->params[3]);
				}
				bi.pos = float3(ci->params[0], ci->params[1], ci->params[2]);
				bi.pos = helper->Pos2BuildPos(bi);

				cursorIcons.AddBuildIcon(ci->id, bi.pos, owner->team, bi.buildFacing);
				lineDrawer.DrawLine(bi.pos, cmdColors.build);

				// draw metal extraction range
				if (bi.def->extractRange > 0) {
					lineDrawer.Break(bi.pos, cmdColors.build);
					glColor4fv(cmdColors.rangeExtract);
					glSurfaceCircle(bi.pos, bi.def->extractRange, 40);
					lineDrawer.Restart();
				}
			}
		}
	}
	lineDrawer.FinishPath();
}
Exemple #17
0
void drawScene1(){
	glTranslatef(0, 0, -ZOOM - 14);

	glPushMatrix();

		glRotatef(-mouseDragSumY * MOUSE_SENSITIVITY, 1, 0, 0);
		glRotatef(-mouseDragSumX * MOUSE_SENSITIVITY, 0, 1, 0);
		glRotatef(-autoRotateY / 20.0, 1, 0, 0);
		glRotatef(-autoRotateX / 20.0, 0, 1, 0);
		glRotatef(-90, 0, 0, 1);

		glLineWidth(1);
		glPointSize(3);

		float alpha1 = sin(count/180.0 * M_PI) * .5 + .5;
		float alpha2 = -sin(count/180.0 * M_PI) * .5 + .5;

		glPushMatrix();
			glScalef(2.8, 2.8, 2.8);
			glColor4f(0.0, 0.0, 0.0, 0.05);
			drawGeodesicExtrudedTriangles(&mesh[5]);
		glPopMatrix();

		for(int i = 2; i < maxFrequency; i++){
			glPushMatrix();
				// glScalef(3 + i/50.0, 3 + i/50.0, 3 + i/50.0);
				glScalef(3, 3, 3);
				// glColor4f(0.0, 0.0, 0.0, 0.1 + powf(12 - i,2)/1000.0);
				glColor4f(0.0, 0.0, 0.0, 0.07);
				if(i == 3 || i == 6 || i == 9 || i == 12)
					glColor4f(0.0, 0.0, 0.0, 0.16);
				// drawGeodesicPoints(&geodesicV[i]);

				glLineWidth(1);
				drawGeodesicLines(&geodesicV[i]);
				// drawGeodesicFaces(&geodesicV[i]);

				glLineWidth(1);
				glColor4f(0.0, 0.0, 0.66, 0.15);
				drawGeodesicVertexNormalLines(&normalsV[i]);
				glColor4f(0.0, 0.66, 0.0, 0.15);
				drawGeodesicLineNormalLines(&normalsV[i]);
				glColor4f(0.66, 0.0, 0.0, 0.15);
				drawGeodesicFaceNormalLines(&normalsV[i]);
			glPopMatrix();
		}

		glLineWidth(1);
		glCullFace(GL_BACK);
		glColor4f(1.0, 1.0, 1.0, 1.0);
		glPushMatrix();
			glScalef(2.95, 2.95, 2.95);
			drawPlatonicSolidFaces(3);
		glPopMatrix();
		glCullFace(GL_FRONT);

		glColor4f(0.0, 0.0, 0.0, 0.1);
		glPushMatrix();
			glScalef(3.9, 3.9, 3.9);
			drawPlatonicSolidLines(4);
		glPopMatrix();

		glLineWidth(8);
		glColor4f(0.0, 0.0, 0.0, 0.04);
		glPushMatrix();
			glScalef(3, 3, 3);
			drawPlatonicSolidLines(3);
		glPopMatrix();

		glLineWidth(4);
		glColor4f(0.0, 0.0, 0.0, 0.03);
		glPushMatrix();
			glScalef(3.01, 3.01, 3.01);
			drawPlatonicSolidLines(3);
		glPopMatrix();

		glLineWidth(1);
		glColor4f(0.0, 0.0, 0.0, 0.02);
		glPushMatrix();
			glScalef(3.02, 3.02, 3.02);
			drawPlatonicSolidLines(3);
		glPopMatrix();

		glLineWidth(2);
		glPushMatrix();
			glScalef(3, 3, 3);
			glColor4f(0.0, 0.0, 0.0, 0.3);
			drawGeodesicVertexNormalLines(&normalsV[2]);
			glColor4f(0.0, 0.0, 0.0, 0.3);
			drawGeodesicLineNormalLines(&normalsV[2]);
			glColor4f(0.0, 0.0, 0.0, 0.3);
			drawGeodesicFaceNormalLines(&normalsV[2]);
		glPopMatrix();

	glPopMatrix();
}
Exemple #18
0
void CShadowHandler::CreateShadows()
{
	fb.Bind();

	glDisable(GL_BLEND);
	glDisable(GL_LIGHTING);
	glDisable(GL_ALPHA_TEST);
	glDisable(GL_TEXTURE_2D);

	glShadeModel(GL_FLAT);
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);

	glViewport(0, 0, shadowMapSize, shadowMapSize);

	// glClearColor(0, 0, 0, 0);
	// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClear(GL_DEPTH_BUFFER_BIT);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0, 1, 0, 1, 0, -1);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();


	const ISkyLight* L = sky->GetLight();

	// sun direction is in world-space, invert it
	sunDirZ = -L->GetLightDir();
	sunDirX = (sunDirZ.cross(UpVector)).ANormalize();
	sunDirY = (sunDirX.cross(sunDirZ)).ANormalize();

	SetShadowMapSizeFactors();

	// NOTE:
	//     the xy-scaling factors from CalcMinMaxView do not change linearly
	//     or smoothly with camera movements, creating visible artefacts (eg.
	//     large jumps in shadow resolution)
	//
	//     therefore, EITHER use "fixed" scaling values such that the entire
	//     map barely fits into the sun's frustum (by pretending it is embedded
	//     in a sphere and taking its diameter), OR variable scaling such that
	//     everything that can be seen by the camera maximally fills the sun's
	//     frustum (choice of projection-style is left to the user and can be
	//     changed at run-time)
	//
	//     the first option means larger maps will have more blurred/aliased
	//     shadows if the depth buffer is kept at the same size, but no (map)
	//     geometry is ever omitted
	//
	//     the second option means shadows have higher average resolution, but
	//     become less sharp as the viewing volume increases (through eg.camera
	//     rotations) and geometry can be omitted in some cases
	//
	// NOTE:
	//     when DynamicSun is enabled, the orbit is always circular in the xz
	//     plane, instead of elliptical when the map has an aspect-ratio != 1
	//
	const float xyScale = GetShadowProjectionRadius(camera, centerPos, -sunDirZ);
	const float xScale = xyScale;
	const float yScale = xyScale;
	const float zScale = globalRendering->viewRange;

	shadowMatrix[ 0] = sunDirX.x / xScale;
	shadowMatrix[ 1] = sunDirY.x / yScale;
	shadowMatrix[ 2] = sunDirZ.x / zScale;

	shadowMatrix[ 4] = sunDirX.y / xScale;
	shadowMatrix[ 5] = sunDirY.y / yScale;
	shadowMatrix[ 6] = sunDirZ.y / zScale;

	shadowMatrix[ 8] = sunDirX.z / xScale;
	shadowMatrix[ 9] = sunDirY.z / yScale;
	shadowMatrix[10] = sunDirZ.z / zScale;

	// rotate the target position into sun-space for the translation
	shadowMatrix[12] = (-sunDirX.dot(centerPos) / xScale);
	shadowMatrix[13] = (-sunDirY.dot(centerPos) / yScale);
	shadowMatrix[14] = (-sunDirZ.dot(centerPos) / zScale) + 0.5f;

	glLoadMatrixf(shadowMatrix.m);

	// set the shadow-parameter registers
	// NOTE: so long as any part of Spring rendering still uses
	// ARB programs at run-time, these lines can not be removed
	// (all ARB programs share the same environment)
	glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 16, shadowTexProjCenter.x, shadowTexProjCenter.y, 0.0f, 0.0f);
	glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 17, shadowTexProjCenter.z, shadowTexProjCenter.z, 0.0f, 0.0f);
	glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 18, shadowTexProjCenter.w, shadowTexProjCenter.w, 0.0f, 0.0f);

	if (globalRendering->haveGLSL) {
		for (int i = 0; i < SHADOWGEN_PROGRAM_LAST; i++) {
			shadowGenProgs[i]->Enable();
			shadowGenProgs[i]->SetUniform4fv(0, &shadowTexProjCenter.x);
			shadowGenProgs[i]->Disable();
		}
	}

	if (L->GetLightIntensity() > 0.0f) {
		// move view into sun-space
		const float3 oldup = camera->up;

		camera->right = sunDirX;
		camera->up = sunDirY;

		DrawShadowPasses();

		camera->up = oldup;
	}

	glShadeModel(GL_SMOOTH);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

	// we do this later to save render context switches (this is one of the slowest opengl operations!)
	// fb.Unbind();
	// glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);
}
void OpenGLContext::copyTexture (const Rectangle<int>& targetClipArea,
                                 const Rectangle<int>& anchorPosAndTextureSize,
                                 const int contextWidth, const int contextHeight)
{
    if (contextWidth <= 0 || contextHeight <= 0)
        return;

    JUCE_CHECK_OPENGL_ERROR
    glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
    glEnable (GL_BLEND);

   #if JUCE_USE_OPENGL_SHADERS
    if (areShadersAvailable())
    {
        struct OverlayShaderProgram  : public ReferenceCountedObject
        {
            OverlayShaderProgram (OpenGLContext& context)
                : program (context), builder (program), params (program)
            {}

            static const OverlayShaderProgram& select (OpenGLContext& context)
            {
                static const char programValueID[] = "juceGLComponentOverlayShader";
                OverlayShaderProgram* program = static_cast <OverlayShaderProgram*> (context.getAssociatedObject (programValueID));

                if (program == nullptr)
                {
                    program = new OverlayShaderProgram (context);
                    context.setAssociatedObject (programValueID, program);
                }

                program->program.use();
                return *program;
            }

            struct ProgramBuilder
            {
                ProgramBuilder (OpenGLShaderProgram& prog)
                {
                    prog.addShader ("attribute " JUCE_HIGHP " vec2 position;"
                                    "uniform " JUCE_HIGHP " vec2 screenSize;"
                                    "varying " JUCE_HIGHP " vec2 pixelPos;"
                                    "void main()"
                                    "{"
                                    "pixelPos = position;"
                                    JUCE_HIGHP " vec2 scaled = position / (0.5 * screenSize.xy);"
                                    "gl_Position = vec4 (scaled.x - 1.0, 1.0 - scaled.y, 0, 1.0);"
                                    "}",
                                    GL_VERTEX_SHADER);

                    prog.addShader ("uniform sampler2D imageTexture;"
                                    "uniform " JUCE_HIGHP " float textureBounds[4];"
                                    "varying " JUCE_HIGHP " vec2 pixelPos;"
                                    "void main()"
                                    "{"
                                     JUCE_HIGHP " vec2 texturePos = (pixelPos - vec2 (textureBounds[0], textureBounds[1]))"
                                                                      "/ vec2 (textureBounds[2], textureBounds[3]);"
                                     "gl_FragColor = texture2D (imageTexture, vec2 (texturePos.x, 1.0 - texturePos.y));"
                                    "}",
                                    GL_FRAGMENT_SHADER);
                    prog.link();
                }
            };

            struct Params
            {
                Params (OpenGLShaderProgram& prog)
                    : positionAttribute (prog, "position"),
                      screenSize (prog, "screenSize"),
                      imageTexture (prog, "imageTexture"),
                      textureBounds (prog, "textureBounds")
                {}

                void set (const float targetWidth, const float targetHeight, const Rectangle<float>& bounds) const
                {
                    const GLfloat m[] = { bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight() };
                    textureBounds.set (m, 4);
                    imageTexture.set (0);
                    screenSize.set (targetWidth, targetHeight);
                }

                OpenGLShaderProgram::Attribute positionAttribute;
                OpenGLShaderProgram::Uniform screenSize, imageTexture, textureBounds;
            };

            OpenGLShaderProgram program;
            ProgramBuilder builder;
            Params params;
        };

        const GLshort left   = (GLshort) targetClipArea.getX();
        const GLshort top    = (GLshort) targetClipArea.getY();
        const GLshort right  = (GLshort) targetClipArea.getRight();
        const GLshort bottom = (GLshort) targetClipArea.getBottom();
        const GLshort vertices[] = { left, bottom, right, bottom, left, top, right, top };

        const OverlayShaderProgram& program = OverlayShaderProgram::select (*this);
        program.params.set ((float) contextWidth, (float) contextHeight, anchorPosAndTextureSize.toFloat());

        extensions.glVertexAttribPointer (program.params.positionAttribute.attributeID, 2, GL_SHORT, GL_FALSE, 4, vertices);
        extensions.glEnableVertexAttribArray (program.params.positionAttribute.attributeID);
        JUCE_CHECK_OPENGL_ERROR

        glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);

        extensions.glUseProgram (0);
        extensions.glDisableVertexAttribArray (program.params.positionAttribute.attributeID);
    }
    #if JUCE_USE_OPENGL_FIXED_FUNCTION
    else
    #endif
   #endif

   #if JUCE_USE_OPENGL_FIXED_FUNCTION
    {
        glEnable (GL_SCISSOR_TEST);
        glScissor (targetClipArea.getX(), contextHeight - targetClipArea.getBottom(),
                   targetClipArea.getWidth(), targetClipArea.getHeight());

        JUCE_CHECK_OPENGL_ERROR
        glColor4f (1.0f, 1.0f, 1.0f, 1.0f);
        glDisableClientState (GL_COLOR_ARRAY);
        glDisableClientState (GL_NORMAL_ARRAY);
        glEnableClientState (GL_VERTEX_ARRAY);
        glEnableClientState (GL_TEXTURE_COORD_ARRAY);
        OpenGLHelpers::prepareFor2D (contextWidth, contextHeight);
        JUCE_CHECK_OPENGL_ERROR

        const GLfloat textureCoords[] = { 0, 0, 1.0f, 0, 0, 1.0f, 1.0f, 1.0f };
        glTexCoordPointer (2, GL_FLOAT, 0, textureCoords);

        const GLshort left   = (GLshort) anchorPosAndTextureSize.getX();
        const GLshort right  = (GLshort) anchorPosAndTextureSize.getRight();
        const GLshort top    = (GLshort) (contextHeight - anchorPosAndTextureSize.getY());
        const GLshort bottom = (GLshort) (contextHeight - anchorPosAndTextureSize.getBottom());
        const GLshort vertices[] = { left, bottom, right, bottom, left, top, right, top };
        glVertexPointer (2, GL_SHORT, 0, vertices);

        glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
        glDisable (GL_SCISSOR_TEST);
    }
   #endif

    JUCE_CHECK_OPENGL_ERROR
}
Exemple #20
0
static void
setup_legacy_const_attribute (CoglContext *ctx,
                              CoglPipeline *pipeline,
                              CoglAttribute *attribute)
{
#ifdef COGL_PIPELINE_PROGEND_GLSL
  if (attribute->name_state->name_id == COGL_ATTRIBUTE_NAME_ID_CUSTOM_ARRAY)
    {
      if (ctx->private_feature_flags & COGL_PRIVATE_FEATURE_GL_PROGRAMMABLE)
        setup_generic_const_attribute (ctx, pipeline, attribute);
    }
  else
#endif
    {
      float vector[4] = { 0, 0, 0, 1 };
      float *boxed = attribute->d.constant.boxed.v.float_value;
      int n_components = attribute->d.constant.boxed.size;
      int i;

      for (i = 0; i < n_components; i++)
        vector[i] = boxed[i];

      switch (attribute->name_state->name_id)
        {
        case COGL_ATTRIBUTE_NAME_ID_COLOR_ARRAY:
          GE (ctx, glColor4f (vector[0], vector[1], vector[2], vector[3]));
          break;
        case COGL_ATTRIBUTE_NAME_ID_NORMAL_ARRAY:
          GE (ctx, glNormal3f (vector[0], vector[1], vector[2]));
          break;
        case COGL_ATTRIBUTE_NAME_ID_TEXTURE_COORD_ARRAY:
          {
            int layer_number = attribute->name_state->layer_number;
            const CoglPipelineGetLayerFlags flags =
              COGL_PIPELINE_GET_LAYER_NO_CREATE;
            CoglPipelineLayer *layer =
              _cogl_pipeline_get_layer_with_flags (pipeline,
                                                   layer_number,
                                                   flags);

            if (layer)
              {
                int unit = _cogl_pipeline_layer_get_unit_index (layer);

                GE (ctx, glClientActiveTexture (GL_TEXTURE0 + unit));

                GE (ctx, glMultiTexCoord4f (vector[0],
                                            vector[1],
                                            vector[2],
                                            vector[3]));
              }
            break;
          }
        case COGL_ATTRIBUTE_NAME_ID_POSITION_ARRAY:
          GE (ctx, glVertex4f (vector[0], vector[1], vector[2], vector[3]));
          break;
        default:
          g_warn_if_reached ();
        }
    }
}
void CSm3GroundDrawer::Draw(bool drawWaterReflection,bool drawUnitReflection,unsigned int overrideVP)
{
	if(drawUnitReflection || drawWaterReflection)
		return;

	terrain::RenderContext *currc;
	if (drawWaterReflection)
	{
		if (!reflectrc)
		{
			reflectrc = tr->AddRenderContext(&reflectCam, true);
			tr->Update();
		}

		SpringCamToTerrainCam(*camera, reflectCam);
		currc = reflectrc;
	} else 
		currc = rc;

	tr->SetShaderParams(gs->sunVector, currc->cam->pos);

	if (shadowHandler->drawShadows)
	{
		terrain::ShadowMapParams params;

		shadowHandler->GetShadowMapSizeFactors (params.f_a, params.f_b);
		params.mid [0] = shadowHandler->xmid;
		params.mid [1] = shadowHandler->ymid;
		params.shadowMap = shadowHandler->shadowTexture;
		for (int a=0;a<16;a++) 
			params.shadowMatrix[a] = shadowHandler->shadowMatrix[a];

		tr->SetShadowParams (&params);
	}

	tr->SetActiveContext (currc);

	glEnable(GL_CULL_FACE);
	glFrontFace(GL_CW);

	glColor4f(1.0f,1.0f,1.0f,1.0f);
	glEnable(GL_LIGHTING);
	glLightfv(GL_LIGHT0, GL_POSITION,gs->sunVector4);
	float d[4]={0.0f,0.0f,0.0f,1.0f};
	for (int a=0;a<3;a++) d[a]=map->sunColor[a];
	glLightfv(GL_LIGHT0, GL_DIFFUSE, d);
	for (int a=0;a<3;a++) d[a]=map->ambientColor[a];
	glLightfv(GL_LIGHT0, GL_AMBIENT, d);
	for (int a=0;a<3;a++) d[a]=map->specularColor[a];
	glLightfv (GL_LIGHT0, GL_SPECULAR, d);
	for (int a=0;a<4;a++) d[a]=0.0f;
	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, d);
	const float zero[] = { 0.0f, 0.0f, 0.0f, 1.0f };
	glLightModelfv (GL_LIGHT_MODEL_AMBIENT, zero);
	glDisable(GL_LIGHT1);
	glEnable(GL_LIGHT0);
	glEnable(GL_RESCALE_NORMAL);

//	glLightfv (GL_LIGHT0, GL_SPOT_DIRECTION,dir.getf());
//	glLightf (GL_LIGHT0, GL_SPOT_CUTOFF, 90.0f);
/*	const float ambient[] = { 0.4f, 0.4f, 0.4f, 1.0f };
	const float diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);
	glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);

	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);

	const float md[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, md);
	glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, md);
	glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 10.0f);*/
	/////////////////////

	tr->Draw ();
	glDisable(GL_LIGHT0);
	glDisable(GL_LIGHTING);


	if (drawMode != drawNormal)
	{
		glEnable(GL_BLEND);
		glDepthMask(GL_FALSE);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glEnable(GL_POLYGON_OFFSET_FILL);
		glPolygonOffset(0.0f,- 10.0f);
		glColor4f(1.0f,1.0f,1.0f,0.5f);
		tr->DrawOverlayTexture (infoTex);
		glDisable(GL_POLYGON_OFFSET_FILL);
		glDepthMask(GL_FALSE);
		glDisable(GL_BLEND);
	}

	glFrontFace(GL_CCW);
	glDisable(GL_CULL_FACE);

	glColor3ub(255,255,255);

	DrawObjects(drawWaterReflection, drawUnitReflection);

	glActiveTextureARB(GL_TEXTURE0_ARB);
	glDisable(GL_TEXTURE_2D);
}
Exemple #22
0
static void redrawTheWindow()
{
	float const aspect = (float)width / (float)height;

	static float a=0;
	static float b=0;
	static float c=0;

	glDrawBuffer(GL_BACK);

	glViewport(0, 0, width, height);

	// Clear with alpha = 0.0, i.e. full transparency
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glFrustum(-aspect, aspect, -1, 1, 2.5, 10);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);

#if 0
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif

	glLightfv(GL_LIGHT0, GL_POSITION, light0_dir);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);

	glLightfv(GL_LIGHT1, GL_POSITION, light1_dir);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_color);

	glLightfv(GL_LIGHT2, GL_POSITION, light2_dir);
	glLightfv(GL_LIGHT2, GL_DIFFUSE, light2_color);

	glTranslatef(0., 0., -5.);

	glRotatef(a, 1, 0, 0);
	glRotatef(b, 0, 1, 0);
	glRotatef(c, 0, 0, 1);

	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHT1);
	glEnable(GL_LIGHTING);

	glEnable(GL_COLOR_MATERIAL);
	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

	glColor4f(1., 1., 1., 0.5);

	glCullFace(GL_FRONT);
	draw_cube();
	glCullFace(GL_BACK);
	draw_cube();

	a = fmod(a+0.1, 360.);
	b = fmod(b+0.5, 360.);
	c = fmod(c+0.25, 360.);

 	glXSwapBuffers(Xdisplay, glX_window_handle);
}
Exemple #23
0
void W_slider::Draw()
{
	glTranslated(posx, posy, 0);
	// Black outlining
	/*glColor4f(0.3f,0.3f,0.3f,0.5f);
	glBegin(GL_POLYGON);
		glVertex2d(6, 0);
		glVertex2d(width-6, 0);
		glVertex2d(width-2, -1);
		glVertex2d(width-1, -3);
		glVertex2d(width, -6);
		glVertex2d(width, -height+6);
		glVertex2d(width-1, -height+2);
		glVertex2d(width-3, -height+1);
		glVertex2d(width-6, -height);
		glVertex2d(6, -height);
		glVertex2d(2, -height+1);
		glVertex2d(1, -height+3);
		glVertex2d(0, -height+6);
		glVertex2d(0, -6);
		glVertex2d(1, -2);
		glVertex2d(3, -1);
		glVertex2d(6, 0);
	glEnd();*/

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	// Fill
	// glColor4f(1.0f, 1.0f, 1.0f,0.6f);
	// glColor4f(0.64f, 0.59f, 0.53f,1.0f);
	// glColor4f(0.75f, 0.75f, 0.75f,1.0f);
	// glColor4f(1.0f, 1.0f, 1.0f,0.4f);
	glColor4f(1.0f, 1.0f, 1.0f,0.4f);
	glBegin(GL_POLYGON);
		glVertex2d(6, -1);
		glVertex2d(width-6, -1);
		glVertex2d(width-2, -2);
		glVertex2d(width-1, -4);
		glVertex2d(width-1, -6);
		glVertex2d(width-1, -height+6);
		glVertex2d(width-2, -height+2);
		glVertex2d(width-4, -height+1);
		glVertex2d(width-6, -height+1);
		glVertex2d(6, -height+1);
		glVertex2d(2, -height+2);
		glVertex2d(1, -height+4);
		glVertex2d(1, -height+5);
		glVertex2d(1, -7);
		glVertex2d(2, -2);
		glVertex2d(4, -1);
		glVertex2d(6, 0);
	glEnd();

	// draw a stripe in the buttons to indicate the current value

    glBegin(GL_QUADS);
    glColor4f(r,g,b,0.3f);

	if (vertical)
	{
        glVertex2d(0,(value-from)/(to-from)*height-height);
        glVertex2d(width,(value-from)/(to-from)*height-height);
        if (barSize){
            glVertex2d(width,(value+barSize-from)/(to-from)*height-height);
            glVertex2d(0,(value+barSize-from)/(to-from)*height-height);
        }
        else{
            glVertex2d(0,-height+1);
            glVertex2d(0, -1);
        }

	}else{
        glVertex2d((value-from)/(to-from)*width,-1);
        glVertex2d((value-from)/(to-from)*width,-height+1);
        if (barSize){
            glVertex2d((value+barSize-from)/(to-from)*width,-height+1);
            glVertex2d((value+barSize-from)/(to-from)*width, -1);
        }
        else{
            glVertex2d(0,-height+1);
            glVertex2d(0, -1);
        }
    }
        glEnd();
/*
        glBegin(GL_QUADS);
            glColor4f(r,g,b,0.3f);

            glVertex2d((value-from)/(to-from)*width,-1);
            glVertex2d((value-from)/(to-from)*width,-height+1);
            if (barSize){
                glVertex2d((value+barSize-from)/(to-from)*width,-height+1);
                glVertex2d((value+barSize-from)/(to-from)*width, -1);
            }
            else{
                glVertex2d(0,-height+1);
                glVertex2d(0, -1);
            }
        glEnd();
	}*/

	// draw the border
	glColor4f(1.0f,1.0f,1.0f,0.7f);

	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, textures.slider.texID);

	glBegin(GL_QUADS);
		glTexCoord2f(0.0f,1.0f);
		glVertex2d(0, 0);
		glTexCoord2f(0.25f,1.0f);
		glVertex2d(8, 0);
		glTexCoord2f(0.25,0.75f);
		glVertex2d(8, -8);
		glTexCoord2f(0.0f,0.75f);
		glVertex2d(0, -8);

		glTexCoord2f(0.49f,1.0f);
		glVertex2d(8, 0);
		glTexCoord2f(0.51f,1.0f);
		glVertex2d(width-8, 0);
		glTexCoord2f(0.51f,0.75f);
		glVertex2d(width-8, -8);
		glTexCoord2f(0.49f,0.75f);
		glVertex2d(8, -8);

		glTexCoord2f(0.75f,1.0f);
		glVertex2d(width-8, 0);
		glTexCoord2f(1.00f,1.0f);
		glVertex2d(width, 0);
		glTexCoord2f(1.00f,0.75f);
		glVertex2d(width, -8);
		glTexCoord2f(0.75f,0.75f);
		glVertex2d(width-8, -8);

		glTexCoord2f(0.75f,0.75f);
		glVertex2d(width-8, -8);
		glTexCoord2f(1.00f,0.75f);
		glVertex2d(width, -8);
		glTexCoord2f(1.00f,0.25f);
		glVertex2d(width, -height+8);
		glTexCoord2f(0.75f,0.25f);
		glVertex2d(width-8, -height+8);

		glTexCoord2f(0.75f,0.25f);
		glVertex2d(width-8, -height+8);
		glTexCoord2f(1.00f,0.25f);
		glVertex2d(width, -height+8);
		glTexCoord2f(1.00f,0.00f);
		glVertex2d(width, -height);
		glTexCoord2f(0.75f,0.00f);
		glVertex2d(width-8, -height);

		glTexCoord2f(0.25f,0.25f);
		glVertex2d(8, -height+8);
		glTexCoord2f(0.75f,0.25f);
		glVertex2d(width-8, -height+8);
		glTexCoord2f(0.75,0.00f);
		glVertex2d(width-8, -height);
		glTexCoord2f(0.25f,0.00f);
		glVertex2d(8, -height);

		glTexCoord2f(0.0f,0.25f);
		glVertex2d(0, -height+8);
		glTexCoord2f(0.25f,0.25f);
		glVertex2d(8, -height+8);
		glTexCoord2f(0.25f,0.00f);
		glVertex2d(8, -height);
		glTexCoord2f(0.0f,0.00f);
		glVertex2d(0, -height);

		glTexCoord2f(0.00f,0.75f);
		glVertex2d(0, -8);
		glTexCoord2f(0.25f,0.75f);
		glVertex2d(8, -8);
		glTexCoord2f(0.25f,0.25f);
		glVertex2d(8, -height+8);
		glTexCoord2f(0.00f,0.25f);
		glVertex2d(0, -height+8);
	glEnd();

    glBindTexture(GL_TEXTURE_2D, textures.specular.texID);
    glColor4f(1.0f,1.0f,1.0f,0.6f);
    glBegin(GL_QUADS);
        glTexCoord2f(0.0f,1.0f);
        glVertex2d(0, 0);
        glTexCoord2f(1.0f,1.0f);
        glVertex2d(width, 0);
        glTexCoord2f(1.0f,0.0f);
        glVertex2d(width,-height);
        glTexCoord2f(0.0f,0.0f);
        glVertex2d(0, -height);
    glEnd();


	glDisable(GL_TEXTURE_2D);

	glTranslated(-posx,-posy,0);

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

    UI_widget::Draw();
}
Exemple #24
0
void DrawCreditsText (double time_step){
    double w = (double)param.x_resolution;
    double h = (double)param.y_resolution;
    double offs = 0.0;
    int i;
    TColor col;
    if (moving) y_offset += time_step * 30;

    for (i=0; i < numCredits; i++) {
	offs = h - 100 - y_offset + CreditList[i].offs;

	col = ( CreditList[i].col == 0 ? colWhite : colDYell );
	FT.SetColor (col);
	FT.AutoSizeN (CreditList[i].size);
	FT.DrawString (-1, (int)offs, CreditList[i].text);
    }

    glDisable (GL_TEXTURE_2D);
    glEnableClientState (GL_VERTEX_ARRAY);
    glEnableClientState (GL_COLOR_ARRAY);

    const GLfloat col1[] = {
        bgcol.r, bgcol.g, bgcol.b, bgcol.a,
        bgcol.r, bgcol.g, bgcol.b, bgcol.a,
        bgcol.r, bgcol.g, bgcol.b, bgcol.a,
        bgcol.r, bgcol.g, bgcol.b, bgcol.a,
    };
    const GLfloat col2[] = {
        bgcol.r, bgcol.g, bgcol.b, bgcol.a,
        bgcol.r, bgcol.g, bgcol.b, bgcol.a,
        bgcol.r, bgcol.g, bgcol.b, 0,
        bgcol.r, bgcol.g, bgcol.b, 0
    };

    const GLfloat vtx1[] = {
        0, 0,
        w, 0,
        w, BOTT_Y,
        0, BOTT_Y
    };
    const GLfloat vtx2[] = {
        0, BOTT_Y,
        w, BOTT_Y,
        w, BOTT_Y + 30,
        0, BOTT_Y + 30
    };

    glColorPointer(4, GL_FLOAT, 0, col1);
    glVertexPointer(2, GL_FLOAT, 0, vtx1);
    glDrawArrays(GL_TRIANGLE_FAN,0,4);

    glColorPointer(4, GL_FLOAT, 0, col2);
    glVertexPointer(2, GL_FLOAT, 0, vtx2);
    glDrawArrays(GL_TRIANGLE_FAN,0,4);

    const GLfloat vtx3[] = {
        0, h - TOP_Y,
        w, h - TOP_Y,
        w, h,
        0, h
    };
    const GLfloat vtx4[] = {
        w, h - TOP_Y,
        0, h - TOP_Y,
        0, h - TOP_Y - 30,
        w, h - TOP_Y - 30
    };

    glColorPointer(4, GL_FLOAT, 0, col1);
    glVertexPointer(2, GL_FLOAT, 0, vtx3);
    glDrawArrays(GL_TRIANGLE_FAN,0,4);

    glColorPointer(4, GL_FLOAT, 0, col2);
    glVertexPointer(2, GL_FLOAT, 0, vtx4);
    glDrawArrays(GL_TRIANGLE_FAN,0,4);

    glColor4f (1, 1, 1, 1 );

    glDisableClientState (GL_COLOR_ARRAY);
    glDisableClientState (GL_VERTEX_ARRAY);
    glEnable (GL_TEXTURE_2D);
    if (offs < TOP_Y) y_offset = 0;
}
Exemple #25
0
// Draw function
void Quad::drawFunc()
{
    
    bool ok = false;
    
    // Draw with texture
    unsigned int nv = getNumberOfVertices();
    if (nv > 3) {
        if (!strip) {
            int rem = nv % 4;
            if (rem != 0) std::cerr << "Quad::drawFunc() - Quad have to have multiple of 4 vertices, add or remove vertices!!" << std::endl;
            else {
                BEGIN_DLIST
                glBegin(GL_QUADS);
                ok = true;
            }
        }
        else {
            int rem = nv % 2;
            if (rem != 0) std::cerr << "Quad::drawFunc() - quad strips have to have multiple of 2 vertices, add or remove vertices!!" << std::endl;
            else {
                BEGIN_DLIST
                glBegin(GL_QUAD_STRIP);
                ok = true;
            }
        }
        
        if (ok) {
            // get our regular vertices here
            const osg::Vec3* v = getVertices();

            unsigned int ntc = getNumberOfTextureCoords();
            // draw with texture
            if (ntc > 0 && hasTexture()) {
                const osg::Vec2* texCoord = getTextureCoord();
                unsigned int tc = 0; // texture count
                for (unsigned int i = 0; i < nv; i++) {
                    // add our textures coordinates
                    if (tc < ntc)  lcTexCoord2v(texCoord[tc++].ptr());
                    // now our vertices
                    lcVertex3v( v[i].ptr() );
                }
                
            }
            // draw without texture
            else {
                // get our color gradient and apply it (if we have one)            
                ColorGradient* colGradient = dynamic_cast<ColorGradient*>(getColor());

                for (unsigned int i = 0; i < nv; i++) {
                    if (colGradient != 0) {
                        Basic::Color* col = colGradient->getColorByIdx(i+1);
                        if (col != 0)
                            glColor4f(static_cast<GLfloat>(col->red()),
                                      static_cast<GLfloat>(col->green()),
                                      static_cast<GLfloat>(col->blue()),
                                      static_cast<GLfloat>(col->alpha()));
                    }
                    // now add our vertex
                    lcVertex3v( v[i].ptr() );
                }
            }
            glEnd();
            END_DLIST
        }
    }
    
    else std::cerr << "Quad::drawFunc() - Quad or QuadStrip needs at least 4 vertices!" << std::endl;
Exemple #26
0
void CShareBox::Draw()
{
    const float alpha = std::max(guiAlpha, 0.4f);

    const float mx = MouseX(mouse->lastx);
    const float my = MouseY(mouse->lasty);

    glDisable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glDisable(GL_ALPHA_TEST);

    // Large Box
    glColor4f(0.2f, 0.2f, 0.2f, alpha);
    DrawBox(box);

    // ok Box on mouse over
    if (InBox(mx, my, box + okBox)) {
        glColor4f(0.7f, 0.2f, 0.2f, alpha);
        DrawBox(box + okBox);
    }

    // apply Box on mouse over
    if (InBox(mx, my, box + applyBox)) {
        glColor4f(0.7f, 0.2f, 0.2f, alpha);
        DrawBox(box + applyBox);
    }

    // cancel Box on mouse over
    if (InBox(mx, my, box + cancelBox)) {
        glColor4f(0.7f,0.2f,0.2f,alpha);
        DrawBox(box + cancelBox);
    }

    glColor4f(0.2f, 0.2f, 0.2f, alpha);
    DrawBox(box + teamBox);

    if (hasScroll) {
        glColor4f(0.1f, 0.1f, 0.1f, alpha);
        DrawBox(box + scrollbarBox);

        float sz = scrollbarBox.y2 - scrollbarBox.y1;
        float tsz = sz / (float)(MAX_SHARE_TEAMS);
        float psz = tsz * (float)numTeamsDisp;

        scrollBox.y2 = scrollbarBox.y2 - startTeam * tsz;
        scrollBox.y1 = scrollBox.y2 - psz;

        glColor4f(0.8f, 0.8f, 0.8f, alpha);
        DrawBox(box + scrollBox);
    }

    if (InBox(mx, my, box + unitBox)) {
        glColor4f(0.7f, 0.2f, 0.2f, alpha);
    } else {
        glColor4f(0.2f, 0.2f, 0.2f, alpha);
    }

    DrawBox(box + unitBox);

    glColor4f(0.8f, 0.8f, 0.9f, 0.7f);
    DrawBox(box + metalBox);

    glColor4f(0.9f, 0.9f, 0.2f, 0.7f);
    DrawBox(box + energyBox);

    //draw share indicators in metal/energy bars
    glColor4f(0.9f, 0.2f, 0.2f, 0.7f);
    ContainerBox metalShareBox;
    metalShareBox.x1 = metalBox.x1 + metalShare * (metalBox.x2 - metalBox.x1) - 0.005f;
    metalShareBox.x2 = metalShareBox.x1 + 0.01f;
    metalShareBox.y1 = metalBox.y1 - 0.005f;
    metalShareBox.y2 = metalBox.y2 + 0.005f;
    DrawBox(box + metalShareBox);
    ContainerBox energyShareBox;
    energyShareBox.x1 = energyBox.x1 + energyShare * (energyBox.x2 - energyBox.x1) - 0.005f;
    energyShareBox.x2 = energyShareBox.x1 + 0.01f;
    energyShareBox.y1 = energyBox.y1 - 0.005f;
    energyShareBox.y2 = energyBox.y2 + 0.005f;
    DrawBox(box + energyShareBox);

    // show that share units is selected
    if (shareUnits) {
        //DrawBox(box + unitBox);
        glLineWidth(3);
        glBegin(GL_LINE_STRIP);
        glVertex2f(box.x1 + unitBox.x1 + 0.01f, box.y1 + unitBox.y1 + 0.025f);
        glVertex2f(box.x1 + unitBox.x1 + 0.02f, box.y1 + unitBox.y1 + 0.01f);
        glVertex2f(box.x1 + unitBox.x1 + 0.03f, box.y1 + unitBox.y1 + 0.04f);
        glEnd();
        glLineWidth(1);
    }

    font->Begin();

    font->glPrint(box.x1 + (okBox.x1 + okBox.x2) * 0.5f, box.y1 + (okBox.y1 + okBox.y2) * 0.5f, 1, FONT_CENTER | FONT_VCENTER | FONT_SCALE | FONT_NORM, "Ok");
    font->glPrint(box.x1 + (applyBox.x1 + applyBox.x2) * 0.5f, box.y1 + (applyBox.y1 + applyBox.y2) * 0.5f, 1, FONT_CENTER | FONT_VCENTER | FONT_SCALE | FONT_NORM, "Apply");
    font->glPrint(box.x1 + (cancelBox.x1 + cancelBox.x2) * 0.5f, box.y1 + (cancelBox.y1 + cancelBox.y2) * 0.5f, 1, FONT_CENTER | FONT_VCENTER | FONT_SCALE | FONT_NORM, "Cancel");

    font->glPrint(box.x1 + 0.06f, box.y1 + 0.085f, 0.7f, FONT_SCALE | FONT_NORM, "Share selected units");

    font->SetTextColor(1, 1, 0.4f, 0.8f);
    font->glPrint(box.x1 + 0.01f, box.y1 + 0.16f, 0.7f, FONT_SCALE | FONT_NORM, "Share Energy");

    font->SetTextColor(1, 1, 1, 0.8f);
    font->glFormat(box.x1 + 0.25f, box.y1 + 0.12f, 0.7f, FONT_SCALE | FONT_NORM, "%.0f", float(teamHandler->Team(gu->myTeam)->energy));
    font->glFormat(box.x1 + 0.14f, box.y1 + 0.12f, 0.7f, FONT_SCALE | FONT_NORM, "%.0f", teamHandler->Team(gu->myTeam)->energy * energyShare);

    font->SetTextColor(0.8f, 0.8f, 0.9f, 0.8f);
    font->glPrint(box.x1 + 0.01f, box.y1 + 0.22f, 0.7f, FONT_SCALE | FONT_NORM, "Share Metal");

    font->SetTextColor(1, 1, 1, 0.8f);
    font->glFormat(box.x1 + 0.25f, box.y1 + 0.18f, 0.7f, FONT_SCALE | FONT_NORM, "%.0f", float(teamHandler->Team(gu->myTeam)->metal));
    font->glFormat(box.x1 + 0.14f, box.y1 + 0.18f, 0.7f, FONT_SCALE | FONT_NORM, "%.0f", teamHandler->Team(gu->myTeam)->metal * metalShare);

    int teamPos = 0;
    for(int team = startTeam; team < MAX_SHARE_TEAMS && teamPos < numTeamsDisp; ++team, ++teamPos) {
        int actualTeam = team;
        if (team >= gu->myTeam) {
            actualTeam++;
        }
        const float alpha = (shareTeam == actualTeam) ? 0.8f : 0.4f;
        std::string teamName;

        if (teamHandler->Team(actualTeam)->leader >= 0) {
            teamName = playerHandler->Player(teamHandler->Team(actualTeam)->leader)->name;
        } else {
            teamName = "Uncontrolled";
        }

        std::string ally, dead;
        if (teamHandler->Ally(gu->myAllyTeam, teamHandler->AllyTeam(actualTeam))) {
            font->SetTextColor(0.5f, 1.0f, 0.5f, alpha);
            ally = " <Ally>";
        } else {
            font->SetTextColor(1.0f, 0.5f, 0.5f, alpha);
            ally = " <Enemy>";
        }
        if (teamHandler->Team(actualTeam)->isDead) {
            font->SetTextColor(0.5f, 0.5f, 1.0f, alpha);
            dead = " <Dead>";
        }
        if (actualTeam == teamHandler->GaiaTeamID()) {
            font->SetTextColor(0.8f, 0.8f, 0.8f, alpha);
            teamName = "Gaia";
            ally   = " <Gaia>";
        }
        font->glFormat(box.x1 + teamBox.x1 + 0.002f,
                       box.y1 + teamBox.y2 - 0.025f - teamPos * 0.025f,
                       0.7f, FONT_SCALE | FONT_NORM, "Team%i (%s)%s%s", actualTeam,
                       teamName.c_str(), ally.c_str(), dead.c_str());
    }

    font->End();

    glEnable(GL_TEXTURE_2D);
}
Exemple #27
0
/*
=============
R_Mirror
=============
*/
void R_Mirror (void)
{
	float		d;
	msurface_t	*s;
	entity_t	*ent;

	if (!mirror)
		return;

	memcpy (r_base_world_matrix, r_world_matrix, sizeof(r_base_world_matrix));

	d = DotProduct (r_refdef.vieworg, mirror_plane->normal) - mirror_plane->dist;
	VectorMA (r_refdef.vieworg, -2*d, mirror_plane->normal, r_refdef.vieworg);

	d = DotProduct (vpn, mirror_plane->normal);
	VectorMA (vpn, -2*d, mirror_plane->normal, vpn);

	r_refdef.viewangles[0] = -asin (vpn[2])/M_PI*180;
	r_refdef.viewangles[1] = atan2 (vpn[1], vpn[0])/M_PI*180;
	r_refdef.viewangles[2] = -r_refdef.viewangles[2];

	ent = &cl_entities[cl.viewentity];
	if (cl_numvisedicts < MAX_VISEDICTS)
	{
		cl_visedicts[cl_numvisedicts] = ent;
		cl_numvisedicts++;
	}

	gldepthmin = 0.5;
	gldepthmax = 1;
	glDepthRange (gldepthmin, gldepthmax);
	glDepthFunc (GL_LEQUAL);

	R_RenderScene ();
	R_DrawWaterSurfaces ();

	gldepthmin = 0;
	gldepthmax = 0.5;
	glDepthRange (gldepthmin, gldepthmax);
	glDepthFunc (GL_LEQUAL);

	// blend on top
	glEnable (GL_BLEND);
	glMatrixMode(GL_PROJECTION);
	if (mirror_plane->normal[2])
		glScalef (1,-1,1);
	else
		glScalef (-1,1,1);
	glCullFace(GL_FRONT);
	glMatrixMode(GL_MODELVIEW);

	glLoadMatrixf (r_base_world_matrix);

	glColor4f (1,1,1,r_mirroralpha.value);
	s = cl.worldmodel->textures[mirrortexturenum]->texturechain;
	for ( ; s ; s=s->texturechain)
		R_RenderBrushPoly (s);
	cl.worldmodel->textures[mirrortexturenum]->texturechain = NULL;
	glDisable (GL_BLEND);
	glColor4f (1,1,1,1);
}
void drawGlow(Camera *pCam, Player *pTarget, PlayerVisual *pV,
							Visual *d, float dim) {
  float mat[4*4];
  float alpha, dist;
	float x, y;

  glPushMatrix();
	
	getPositionFromData(&x, &y, pTarget->data);
  glTranslatef(x, y, 0);

  glDepthMask(GL_FALSE);
  glEnable(GL_DEPTH_TEST);

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

  glGetFloatv(GL_MODELVIEW_MATRIX, mat);
  mat[0] = mat[5] = mat[10] = 1.0;
  mat[1] = mat[2] = 0.0;
  mat[4] = mat[6] = 0.0;
  mat[8] = mat[9] = 0.0;
  glLoadMatrixf(mat);

	{
		vec3 v;
		v.v[0] = x - pCam->cam[0];
		v.v[1] = y - pCam->cam[1];
		v.v[2] = 0 - pCam->cam[2];
		dist = vec3Length(&v);
	}
	{
	  const float fMin = 30;
		const float fMax = 100;
		if(dist < fMin) alpha = 0.0f;
		else if(dist > fMax) alpha = 1.0f;
		else alpha = (dist - fMin) / (fMax - fMin);
		// printf("dist: %.2f, alpha: %.2f\n", dist, alpha);
	}
  glBegin(GL_TRIANGLE_FAN);
  glColor4f(pV->pColorDiffuse[0], 
						pV->pColorDiffuse[1], 
						pV->pColorDiffuse[2],
						alpha);

  glVertex3f(0,TRAIL_HEIGHT/2, 0);
  glColor4f(0,0,0,0.0);
  glVertex3d(dim*cos(-0.2*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(-0.2*3.1415/5.0), 0);
  glVertex3d(dim*cos(1.0*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(1.0*3.1415/5.0), 0);
  glVertex3d(dim*cos(2.0*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(2.0*3.1415/5.0), 0);
  glVertex3d(dim*cos(3.0*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(3.0*3.1415/5.0), 0);
  glVertex3d(dim*cos(4.0*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(4.0*3.1415/5.0), 0);
  glVertex3d(dim*cos(5.2*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(5.2*3.1415/5.0), 0);
  glEnd();
  polycount += 5;


  glBegin(GL_TRIANGLES);
  glColor4f(pV->pColorDiffuse[0], 
						pV->pColorDiffuse[1], 
						pV->pColorDiffuse[2],
						alpha);
  glVertex3f(0,TRAIL_HEIGHT/2, 0);
  glColor4f(0,0,0,0.0);
  glVertex3f(0,-TRAIL_HEIGHT/4,0);
  glVertex3d(dim*cos(-0.2f*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(-0.2*3.1415/5.0), 0);

  glColor4f(pV->pColorDiffuse[0], 
						pV->pColorDiffuse[1], 
						pV->pColorDiffuse[2],
						alpha);
  glVertex3f(0,TRAIL_HEIGHT/2, 0);
  glColor4f(0,0,0,0.0);
  glVertex3d(dim*cos(5.2*3.1415/5.0),
	     TRAIL_HEIGHT/2+dim*sin(5.2*3.1415/5.0), 0);
  glVertex3f(0,-TRAIL_HEIGHT/4,0);
  glEnd();
  polycount += 3;

  glDepthMask(GL_TRUE);
  glEnable(GL_DEPTH_TEST);

  glPopMatrix();  
}
Exemple #29
0
void SimpleOpenGL2App::drawText3D( const char* txt, float worldPosX, float worldPosY, float worldPosZ, float size1)
{
	saveOpenGLState(gApp2->m_renderer->getScreenWidth(),gApp2->m_renderer->getScreenHeight());
	float viewMat[16];
	float projMat[16];
	CommonCameraInterface* cam = gApp2->m_renderer->getActiveCamera();

	cam->getCameraViewMatrix(viewMat);
	cam->getCameraProjectionMatrix(projMat);

	
	float camPos[4];
	cam->getCameraPosition(camPos);
	//b3Vector3 cp= b3MakeVector3(camPos[0],camPos[2],camPos[1]);
//	b3Vector3 p = b3MakeVector3(worldPosX,worldPosY,worldPosZ);

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

	glAlphaFunc( GL_GREATER, 1.0f );	
	
			

	int viewport[4]={0,0,gApp2->m_renderer->getScreenWidth(),gApp2->m_renderer->getScreenHeight()};

	float posX = 450.f;
	float posY = 100.f;
	float winx,winy, winz;

	if (!projectWorldCoordToScreen(worldPosX, worldPosY, worldPosZ,viewMat,projMat,viewport,&winx, &winy, &winz))
	{
		return;
	}
	posX = winx;
	posY = gApp2->m_renderer->getScreenHeight()/2+(gApp2->m_renderer->getScreenHeight()/2)-winy;

	
	{
		//float width = 0.f;
		int pos=0;
		//float color[]={0.2f,0.2,0.2f,1.f};
		glActiveTexture(GL_TEXTURE0);
		glMatrixMode(GL_TEXTURE);
		glLoadIdentity();
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		
	
		glBindTexture(GL_TEXTURE_2D,m_data->m_largeFontTextureId);

		glEnable(GL_TEXTURE_2D);//BindTexture
		//float width = r.x;
		//float extraSpacing = 0.;

		float startX = posX;
		float startY = posY-g_DefaultLargeFont->m_CharHeight*size1;
		glEnable(GL_COLOR_MATERIAL);
		
		while (txt[pos])
		{
			int c = txt[pos];
			//r.h = g_DefaultNormalFont->m_CharHeight;
			//r.w = g_DefaultNormalFont->m_CharWidth[c]+extraSpacing;
			float endX = startX+g_DefaultLargeFont->m_CharWidth[c]*size1;
			float endY = posY;


			float currentColor[]={1.f,0.2,0.2f,1.f};
			float u0 = g_DefaultLargeFont->m_CharU0[c];
			float u1 = g_DefaultLargeFont->m_CharU1[c];
			float v0 = g_DefaultLargeFont->m_CharV0[c];
			float v1 = g_DefaultLargeFont->m_CharV1[c];
			float color[4] = {currentColor[0],currentColor[1],currentColor[2],currentColor[3]};
			float x0 = startX;
			float x1 = endX;
			float y0 = startY;
			float y1 = endY;
			int screenWidth = gApp2->m_renderer->getScreenWidth();
			int screenHeight = gApp2->m_renderer->getScreenHeight();
			


			float z = 2.f*winz-1.f;//*(far
			 /*float identity[16]={1,0,0,0,
						0,1,0,0,
						0,0,1,0,
						0,0,0,1};
*/
			   PrimVertex vertexData[4] = {
					PrimVertex( PrimVec4(-1.f+2.f*x0/float(screenWidth), 1.f-2.f*y0/float(screenHeight), z, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v0)),
					PrimVertex( PrimVec4(-1.f+2.f*x0/float(screenWidth),  1.f-2.f*y1/float(screenHeight), z, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v1)),
					PrimVertex(PrimVec4( -1.f+2.f*x1/float(screenWidth),  1.f-2.f*y1/float(screenHeight), z, 1.f ), PrimVec4(color[0], color[1], color[2], color[3]) ,PrimVec2(u1,v1)),
					PrimVertex( PrimVec4( -1.f+2.f*x1/float(screenWidth), 1.f-2.f*y0/float(screenHeight), z, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u1,v0))
				};
    
				glBegin(GL_TRIANGLES);
				//use red colored text for now
				glColor4f(1,0,0,1);
			
				float scaling = 1;
				
				glTexCoord2f(vertexData[0].uv.p[0],vertexData[0].uv.p[1]);
				glVertex3d(vertexData[0].position.p[0]*scaling, vertexData[0].position.p[1]*scaling,vertexData[0].position.p[2]*scaling);
				glTexCoord2f(vertexData[1].uv.p[0],vertexData[1].uv.p[1]);
				glVertex3d(vertexData[1].position.p[0]*scaling, vertexData[1].position.p[1]*scaling,vertexData[1].position.p[2]*scaling);
				glTexCoord2f(vertexData[2].uv.p[0],vertexData[2].uv.p[1]);
				glVertex3d(vertexData[2].position.p[0]*scaling, vertexData[2].position.p[1]*scaling,vertexData[2].position.p[2]*scaling);
				
				glTexCoord2f(vertexData[0].uv.p[0],vertexData[0].uv.p[1]);
				glVertex3d(vertexData[0].position.p[0]*scaling, vertexData[0].position.p[1]*scaling,vertexData[0].position.p[2]*scaling);
				glTexCoord2f(vertexData[2].uv.p[0],vertexData[2].uv.p[1]);
				glVertex3d(vertexData[2].position.p[0]*scaling, vertexData[2].position.p[1]*scaling,vertexData[2].position.p[2]*scaling);
				glTexCoord2f(vertexData[3].uv.p[0],vertexData[3].uv.p[1]);
				glVertex3d(vertexData[3].position.p[0]*scaling, vertexData[3].position.p[1]*scaling,vertexData[3].position.p[2]*scaling);
				
				glEnd();

			startX = endX;
			pos++;
		}
	}

	glBindTexture(GL_TEXTURE_2D,0);
	glDisable(GL_BLEND);
	glDisable(GL_TEXTURE_2D);

	restoreOpenGLState();
}
Exemple #30
0
///////////////////////////////////////////////////////////////////////////////
// draw a textured cube with GL_TRIANGLES
///////////////////////////////////////////////////////////////////////////////
void draw()
{
    glBindTexture(GL_TEXTURE_2D, textureId);

    glColor4f(1, 1, 1, 1);
    glBegin(GL_TRIANGLES);
        // front faces
        glNormal3f(0,0,1);
        // face v0-v1-v2
        glTexCoord2f(1,1);  glVertex3f(1,1,1);
        glTexCoord2f(0,1);  glVertex3f(-1,1,1);
        glTexCoord2f(0,0);  glVertex3f(-1,-1,1);
        // face v2-v3-v0
        glTexCoord2f(0,0);  glVertex3f(-1,-1,1);
        glTexCoord2f(1,0);  glVertex3f(1,-1,1);
        glTexCoord2f(1,1);  glVertex3f(1,1,1);

        // right faces
        glNormal3f(1,0,0);
        // face v0-v3-v4
        glTexCoord2f(0,1);  glVertex3f(1,1,1);
        glTexCoord2f(0,0);  glVertex3f(1,-1,1);
        glTexCoord2f(1,0);  glVertex3f(1,-1,-1);
        // face v4-v5-v0
        glTexCoord2f(1,0);  glVertex3f(1,-1,-1);
        glTexCoord2f(1,1);  glVertex3f(1,1,-1);
        glTexCoord2f(0,1);  glVertex3f(1,1,1);

        // top faces
        glNormal3f(0,1,0);
        // face v0-v5-v6
        glTexCoord2f(1,0);  glVertex3f(1,1,1);
        glTexCoord2f(1,1);  glVertex3f(1,1,-1);
        glTexCoord2f(0,1);  glVertex3f(-1,1,-1);
        // face v6-v1-v0
        glTexCoord2f(0,1);  glVertex3f(-1,1,-1);
        glTexCoord2f(0,0);  glVertex3f(-1,1,1);
        glTexCoord2f(1,0);  glVertex3f(1,1,1);

        // left faces
        glNormal3f(-1,0,0);
        // face  v1-v6-v7
        glTexCoord2f(1,1);  glVertex3f(-1,1,1);
        glTexCoord2f(0,1);  glVertex3f(-1,1,-1);
        glTexCoord2f(0,0);  glVertex3f(-1,-1,-1);
        // face v7-v2-v1
        glTexCoord2f(0,0);  glVertex3f(-1,-1,-1);
        glTexCoord2f(1,0);  glVertex3f(-1,-1,1);
        glTexCoord2f(1,1);  glVertex3f(-1,1,1);

        // bottom faces
        glNormal3f(0,-1,0);
        // face v7-v4-v3
        glTexCoord2f(0,0);  glVertex3f(-1,-1,-1);
        glTexCoord2f(1,0);  glVertex3f(1,-1,-1);
        glTexCoord2f(1,1);  glVertex3f(1,-1,1);
        // face v3-v2-v7
        glTexCoord2f(1,1);  glVertex3f(1,-1,1);
        glTexCoord2f(0,1);  glVertex3f(-1,-1,1);
        glTexCoord2f(0,0);  glVertex3f(-1,-1,-1);

        // back faces
        glNormal3f(0,0,-1);
        // face v4-v7-v6
        glTexCoord2f(0,0);  glVertex3f(1,-1,-1);
        glTexCoord2f(1,0);  glVertex3f(-1,-1,-1);
        glTexCoord2f(1,1);  glVertex3f(-1,1,-1);
        // face v6-v5-v4
        glTexCoord2f(1,1);  glVertex3f(-1,1,-1);
        glTexCoord2f(0,1);  glVertex3f(1,1,-1);
        glTexCoord2f(0,0);  glVertex3f(1,-1,-1);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, 0);
}