自学教程：C++ GLfloat函数代码示例

//.........这里部分代码省略.........    else if (noiseTexture >= 0 && BZDBCache::texture && renderer.useQuality() == 0)		{      glEnable(GL_TEXTURE_2D);      tm.bind(noiseTexture);      glBegin(GL_QUADS);				glTexCoord2f(0,0);				glVertex2f(-range,-range);				glTexCoord2f(1,0);				glVertex2f( range,-range);				glTexCoord2f(1,1);				glVertex2f( range, range);				glTexCoord2f(0,1);				glVertex2f(-range, range);      glEnd();      glDisable(GL_TEXTURE_2D);    }    if (decay > 0.015f)			decay *= 0.5f;  }	else if (myTank)  // only draw if there's a local player	{    // if decay is sufficiently small then boost it so it's more    // likely a jammed radar will get a few good frames closely    // spaced in time.  value of 1 guarantees at least two good    // frames in a row.    if (decay <= 0.015f)			decay = 1.0f;    else			decay *= 0.5f;    // get size of pixel in model space (assumes radar is square)    ps = 2.0f * range / GLfloat(w);    // relative to my tank    const LocalPlayer* myTank = LocalPlayer::getMyTank();    const float* pos = myTank->getPosition();    float angle = myTank->getAngle();    // draw the view angle blewow stuff    // view frustum edges    glColor3f(1.0f, 0.625f, 0.125f);    const float fovx = renderer.getViewFrustum().getFOVx();    const float viewWidth = range * tanf(0.5f * fovx);    glBegin(GL_LINE_STRIP);			glVertex2f(-viewWidth, range);			glVertex2f(0.0f, 0.0f);			glVertex2f(viewWidth, range);    glEnd();    glPushMatrix();    glRotatef(90.0f - angle * 180.0f / M_PI, 0.0f, 0.0f, 1.0f);    glPushMatrix();    glTranslatef(-pos[0], -pos[1], 0.0f);    // Redraw buildings    makeList( renderer);    // draw my shots    int maxShots = world.getMaxShots();    int i;    float muzzleHeight = BZDB.eval(StateDatabase::BZDB_MUZZLEHEIGHT);    for (i = 0; i < maxShots; i++)		{      const ShotPath* shot = myTank->getShot(i);

voidCanvas::DrawCircle(int x, int y, unsigned radius){#ifdef USE_GLSL  OpenGL::solid_shader->Use();#endif  if (IsPenOverBrush() && pen.GetWidth() > 2) {    ScopeVertexPointer vp;    GLDonutVertices vertices(x, y,                             radius - pen.GetWidth() / 2,                             radius + pen.GetWidth() / 2);    if (!brush.IsHollow()) {      vertices.BindInnerCircle(vp);      brush.Set();      glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.CIRCLE_SIZE);    }    vertices.Bind(vp);    pen.Bind();    glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.SIZE);    pen.Unbind();  } else {    GLFallbackArrayBuffer &buffer = radius < 16      ? *OpenGL::small_circle_buffer      : *OpenGL::circle_buffer;    const unsigned n = radius < 16      ? OpenGL::SMALL_CIRCLE_SIZE      : OpenGL::CIRCLE_SIZE;    const FloatPoint *const points = (const FloatPoint *)buffer.BeginRead();    const ScopeVertexPointer vp(points);#ifdef USE_GLSL    glm::mat4 matrix2 = glm::scale(glm::translate(glm::mat4(),                                                  glm::vec3(x, y, 0)),                                   glm::vec3(GLfloat(radius), GLfloat(radius),                                             1.));    glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE,                       glm::value_ptr(matrix2));#else    glPushMatrix();#ifdef HAVE_GLES    glTranslatex((GLfixed)x << 16, (GLfixed)y << 16, 0);    glScalex((GLfixed)radius << 16, (GLfixed)radius << 16, (GLfixed)1 << 16);#else    glTranslatef(x, y, 0.);    glScalef(radius, radius, 1.);#endif#endif    if (!brush.IsHollow()) {      brush.Set();      glDrawArrays(GL_TRIANGLE_FAN, 0, n);    }    if (IsPenOverBrush()) {      pen.Bind();      glDrawArrays(GL_LINE_LOOP, 0, n);      pen.Unbind();    }#ifdef USE_GLSL    glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE,                       glm::value_ptr(glm::mat4()));#else    glPopMatrix();#endif    buffer.EndRead();  }}

voidDecomposeIntoNoRepeatTriangles(const gfx::IntRect& aTexCoordRect,                               const gfx::IntSize& aTexSize,                               RectTriangles& aRects,                               bool aFlipY /* = false */){    // normalize this    gfx::IntRect tcr(aTexCoordRect);    while (tcr.x >= aTexSize.width)        tcr.x -= aTexSize.width;    while (tcr.y >= aTexSize.height)        tcr.y -= aTexSize.height;    // Compute top left and bottom right tex coordinates    GLfloat tl[2] =        { GLfloat(tcr.x) / GLfloat(aTexSize.width),          GLfloat(tcr.y) / GLfloat(aTexSize.height) };    GLfloat br[2] =        { GLfloat(tcr.XMost()) / GLfloat(aTexSize.width),          GLfloat(tcr.YMost()) / GLfloat(aTexSize.height) };    // then check if we wrap in either the x or y axis; if we do,    // then also use fmod to figure out the "true" non-wrapping    // texture coordinates.    bool xwrap = false, ywrap = false;    if (tcr.x < 0 || tcr.x > aTexSize.width ||        tcr.XMost() < 0 || tcr.XMost() > aTexSize.width)    {        xwrap = true;        tl[0] = WrapTexCoord(tl[0]);        br[0] = WrapTexCoord(br[0]);    }    if (tcr.y < 0 || tcr.y > aTexSize.height ||        tcr.YMost() < 0 || tcr.YMost() > aTexSize.height)    {        ywrap = true;        tl[1] = WrapTexCoord(tl[1]);        br[1] = WrapTexCoord(br[1]);    }    NS_ASSERTION(tl[0] >= 0.0f && tl[0] <= 1.0f &&                 tl[1] >= 0.0f && tl[1] <= 1.0f &&                 br[0] >= 0.0f && br[0] <= 1.0f &&                 br[1] >= 0.0f && br[1] <= 1.0f,                 "Somehow generated invalid texture coordinates");    // If xwrap is false, the texture will be sampled from tl[0]    // .. br[0].  If xwrap is true, then it will be split into tl[0]    // .. 1.0, and 0.0 .. br[0].  Same for the Y axis.  The    // destination rectangle is also split appropriately, according    // to the calculated xmid/ymid values.    // There isn't a 1:1 mapping between tex coords and destination coords;    // when computing midpoints, we have to take that into account.  We    // need to map the texture coords, which are (in the wrap case):    // |tl->1| and |0->br| to the |0->1| range of the vertex coords.  So    // we have the length (1-tl)+(br) that needs to map into 0->1.    // These are only valid if there is wrap involved, they won't be used    // otherwise.    GLfloat xlen = (1.0f - tl[0]) + br[0];    GLfloat ylen = (1.0f - tl[1]) + br[1];    NS_ASSERTION(!xwrap || xlen > 0.0f, "xlen isn't > 0, what's going on?");    NS_ASSERTION(!ywrap || ylen > 0.0f, "ylen isn't > 0, what's going on?");    NS_ASSERTION(aTexCoordRect.width <= aTexSize.width &&                 aTexCoordRect.height <= aTexSize.height, "tex coord rect would cause tiling!");    if (!xwrap && !ywrap) {        aRects.addRect(0.0f, 0.0f,                       1.0f, 1.0f,                       tl[0], tl[1],                       br[0], br[1],                       aFlipY);    } else if (!xwrap && ywrap) {        GLfloat ymid = (1.0f - tl[1]) / ylen;        aRects.addRect(0.0f, 0.0f,                       1.0f, ymid,                       tl[0], tl[1],                       br[0], 1.0f,                       aFlipY);        aRects.addRect(0.0f, ymid,                       1.0f, 1.0f,                       tl[0], 0.0f,                       br[0], br[1],                       aFlipY);    } else if (xwrap && !ywrap) {        GLfloat xmid = (1.0f - tl[0]) / xlen;        aRects.addRect(0.0f, 0.0f,                       xmid, 1.0f,                       tl[0], tl[1],                       1.0f, br[1],                       aFlipY);        aRects.addRect(xmid, 0.0f,                       1.0f, 1.0f,                       0.0f, tl[1],                       br[0], br[1],                       aFlipY);    } else {//.........这里部分代码省略.........

/** * if (load) *    Accum = ColorBuf * value * else *    Accum += ColorBuf * value */static voidaccum_or_load(struct gl_context *ctx, GLfloat value,              GLint xpos, GLint ypos, GLint width, GLint height,              GLboolean load){   struct gl_renderbuffer *accRb =      ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;   struct gl_renderbuffer *colorRb = ctx->ReadBuffer->_ColorReadBuffer;   GLubyte *accMap, *colorMap;   GLint accRowStride, colorRowStride;   GLbitfield mappingFlags;   if (!colorRb) {      /* no read buffer - OK */      return;   }   assert(accRb);   mappingFlags = GL_MAP_WRITE_BIT;   if (!load) /* if we're accumulating */      mappingFlags |= GL_MAP_READ_BIT;   /* Map accum buffer */   ctx->Driver.MapRenderbuffer(ctx, accRb, xpos, ypos, width, height,                               mappingFlags, &accMap, &accRowStride);   if (!accMap) {      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");      return;   }   /* Map color buffer */   ctx->Driver.MapRenderbuffer(ctx, colorRb, xpos, ypos, width, height,                               GL_MAP_READ_BIT,                               &colorMap, &colorRowStride);   if (!colorMap) {      ctx->Driver.UnmapRenderbuffer(ctx, accRb);      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");      return;   }   if (accRb->Format == MESA_FORMAT_SIGNED_RGBA_16) {      const GLfloat scale = value * 32767.0f;      GLuint i, j;      GLfloat (*rgba)[4];      rgba = malloc(width * 4 * sizeof(GLfloat));      if (rgba) {         for (j = 0; j < height; j++) {            GLshort *acc = (GLshort *) accMap;            /* read colors from source color buffer */            _mesa_unpack_rgba_row(colorRb->Format, width, colorMap, rgba);            if (load) {               for (i = 0; i < width; i++) {                  acc[i * 4 + 0] = (GLshort) (rgba[i][RCOMP] * scale);                  acc[i * 4 + 1] = (GLshort) (rgba[i][GCOMP] * scale);                  acc[i * 4 + 2] = (GLshort) (rgba[i][BCOMP] * scale);                  acc[i * 4 + 3] = (GLshort) (rgba[i][ACOMP] * scale);               }            }            else {               /* accumulate */               for (i = 0; i < width; i++) {                  acc[i * 4 + 0] += (GLshort) (rgba[i][RCOMP] * scale);                  acc[i * 4 + 1] += (GLshort) (rgba[i][GCOMP] * scale);                  acc[i * 4 + 2] += (GLshort) (rgba[i][BCOMP] * scale);                  acc[i * 4 + 3] += (GLshort) (rgba[i][ACOMP] * scale);               }            }            colorMap += colorRowStride;            accMap += accRowStride;         }         free(rgba);      }      else {         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");      }   }   else {      /* other types someday? */   }   ctx->Driver.UnmapRenderbuffer(ctx, accRb);   ctx->Driver.UnmapRenderbuffer(ctx, colorRb);}

void Surface3d::generateMesh(const Surface& S){	int n = S.getHeight();	int m = S.getWidth();	//set up vertices and normals	vector<Vector> smoothNormals;	getSmoothNormals(smoothNormals);	GLfloat* vertices = new GLfloat[n*m*3];	GLfloat* normals = new GLfloat[n*m*3];	unsigned int verticesStride = 0;	for (int i = 0; i < n; ++i) {		for (int j = 0; j < m; ++j) {			vertices[verticesStride + 0] = GLfloat(j);			vertices[verticesStride + 1] = GLfloat(S.getZ(j, i));			vertices[verticesStride + 2] = GLfloat(i);			normals[verticesStride + 0] = smoothNormals[i*m + j].x; 			normals[verticesStride + 1] = smoothNormals[i*m + j].y;			normals[verticesStride + 2] = smoothNormals[i*m + j].z;			verticesStride += 3;		}	}	glGenBuffers(1, &verticesId);    glBindBuffer(GL_ARRAY_BUFFER, verticesId);    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*verticesStride, vertices, GL_STATIC_DRAW);	glGenBuffers(1, &normalsId);    glBindBuffer(GL_ARRAY_BUFFER, normalsId);    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*verticesStride, normals, GL_STATIC_DRAW);	delete vertices;	delete normals;		//set up indices	//a triangle strip generated by stitching	GLuint* indices = new GLuint[2*m + (n-2)*m*2];	unsigned int indicesStride = 0;	for (int i = 0; i < n-1; ++i) {		for (int j = 0; j < m; ++j) {			indices[indicesStride++] = i*m + j;			indices[indicesStride++] = (i+1)*m + j;		}		++i;		if (i < n-1) {			for (int j = m-1; j >= 0; --j) {				indices[indicesStride++] = i*m + j;				indices[indicesStride++] = (i+1)*m + j;			}		}	}	glGenBuffers(1, &indicesId);    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesId);    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*indicesStride, indices, GL_STATIC_DRAW);	delete indices;	indicesCount = indicesStride;}

void TesseractWidget::SetColor(Coordinate color) {    GLfloat c[4]= {GLfloat(color.x),GLfloat(color.y),GLfloat(color.z),1};    glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,c);    glColor4fv(c);}

// ------------------------------------------------------------------------------------------------// ------------------------------------------------------------------------------------------------// ------------------------------------------------------------------------------------------------Texture2D::Texture2D(Texture2DContainer* container, GLsizei sliceNum): mContainer(container), mSliceNum(GLfloat(sliceNum)){    assert(mContainer);}

void GLLineIlluminator::updateMaterial(GLLineIlluminator::DataItem* dataItem) const	{	/* Update the material version: */	dataItem->materialVersion=materialVersion;		/* Upload the material texture: */	dataItem->materialType=materialType;	if(materialType==INTENSITY)		{		/* Create a 2D texture map encoding Phong's lighting model: */		static GLfloat texture[32][32];		for(int x=0;x<32;++x)			{			GLfloat s=2.0f*(GLfloat(x)+0.5f)/32.0f-1.0f;			GLfloat oneMinusS2=1.0f-s*s;			GLfloat ambientDiffuse=material.diffuse[0];			ambientDiffuse*=Math::pow(Math::sqrt(oneMinusS2),2.0f);			ambientDiffuse+=material.ambient[0];			for(int y=0;y<32;++y)				{				GLfloat t=2.0f*(GLfloat(y)+0.5f)/32.0f-1.0f;				GLfloat oneMinusT2=1.0f-t*t;				GLfloat color=material.specular[0];				color*=Math::pow(Math::abs(Math::sqrt(oneMinusS2*oneMinusT2)-s*t),material.shininess);				color+=ambientDiffuse;				texture[y][x]=color;				}			}				/* Upload the created texture: */		glBindTexture(GL_TEXTURE_2D,dataItem->materialTextureId);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,0);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);		glPixelStorei(GL_UNPACK_ROW_LENGTH,0);		glPixelStorei(GL_UNPACK_SKIP_ROWS,0);		glPixelStorei(GL_UNPACK_SKIP_PIXELS,0);		glPixelStorei(GL_UNPACK_ALIGNMENT,1);		glTexImage2D(GL_TEXTURE_2D,0,GL_INTENSITY,32,32,0,GL_LUMINANCE,GL_FLOAT,texture);		glBindTexture(GL_TEXTURE_2D,0);		}	else if(materialType==RGBA)		{		/* Create a 2D texture map encoding Phong's lighting model: */		static Color texture[32][32];		for(int x=0;x<32;++x)			{			GLfloat s=2.0f*(GLfloat(x)+0.5f)/32.0f-1.0f;			GLfloat oneMinusS2=1.0f-s*s;			Color ambientDiffuse=material.diffuse;			ambientDiffuse*=Math::pow(Math::sqrt(oneMinusS2),2.0f);			ambientDiffuse+=material.ambient;			for(int y=0;y<32;++y)				{				GLfloat t=2.0f*(GLfloat(y)+0.5f)/32.0f-1.0f;				GLfloat oneMinusT2=1.0f-t*t;				Color color=material.specular;				color*=Math::pow(Math::abs(Math::sqrt(oneMinusS2*oneMinusT2)-s*t),material.shininess);				color+=ambientDiffuse;				texture[y][x]=color;				}			}				/* Upload the created texture: */		glBindTexture(GL_TEXTURE_2D,dataItem->materialTextureId);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,0);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);		glPixelStorei(GL_UNPACK_ROW_LENGTH,0);		glPixelStorei(GL_UNPACK_SKIP_ROWS,0);		glPixelStorei(GL_UNPACK_SKIP_PIXELS,0);		glPixelStorei(GL_UNPACK_ALIGNMENT,1);		glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,32,32,0,GL_RGBA,GL_FLOAT,texture);		glBindTexture(GL_TEXTURE_2D,0);		}	}

  void VisualSceneSpecPoints :: DrawScene ()  {    if (!mesh)       {	VisualScene::DrawScene();	return;      }    if (changeval != specpoints.Size())      BuildScene();    changeval = specpoints.Size();    glClearColor(backcolor, backcolor, backcolor, 1.0);    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    glEnable (GL_COLOR_MATERIAL);    glColor3f (1.0f, 1.0f, 1.0f);    glLineWidth (1.0f);    glPushMatrix();    glMultMatrixd (transformationmat);    //  glEnable (GL_COLOR);    //  glDisable (GL_COLOR_MATERIAL);    if (vispar.drawedtangents)      {	glColor3d (1, 0, 0);	glBegin (GL_LINES);	for (int i = 1; i <= specpoints.Size(); i++)	  {	    const Point3d p1 = specpoints.Get(i).p;	    const Point3d p2 = specpoints.Get(i).p + len * specpoints.Get(i).v;	    glVertex3d (p1.X(), p1.Y(), p1.Z());	    glVertex3d (p2.X(), p2.Y(), p2.Z());	  }	glEnd();      }    if (vispar.drawededges)      {	glColor3d (1, 0, 0);	glBegin (GL_LINES);	for (int i = 1; i <= mesh->GetNSeg(); i++)	  {	    const Segment & seg = mesh -> LineSegment (i);	    glVertex3dv ( (*mesh)[seg[0]] );            glVertex3dv ( (*mesh)[seg[1]] );	    // glVertex3dv ( &(*mesh)[seg[0]].X() );	    // glVertex3dv ( &(*mesh)[seg[1]].X() );	  }	glEnd();      }    glColor3d (1, 0, 0);    glBegin (GL_LINES);    int edges[12][2] =       { { 0, 1 },	{ 2, 3 },	{ 4, 5 },	{ 6, 7 },	{ 0, 2 },	{ 1, 3 },	{ 4, 6 },	{ 5, 7 },	{ 0, 4 },	{ 1, 5 },	{ 2, 6 },	{ 3, 7 } };    for (int i = 0; i < boxes.Size(); i++)      {	for (int j = 0; j < 12; j++)	  {	    glVertex3dv ( boxes[i].GetPointNr(edges[j][0]) );	    glVertex3dv ( boxes[i].GetPointNr(edges[j][1]) );	  }	/*	glVertex3dv ( boxes[i].PMin() );	glVertex3dv ( boxes[i].PMax() );	*/      }    glEnd();    if (vispar.drawededgenrs)      {	glEnable (GL_COLOR_MATERIAL);	GLfloat textcol[3] = { GLfloat(1 - backcolor),			       GLfloat(1 - backcolor), 			       GLfloat(1 - backcolor) };	glColor3fv (textcol);	glNormal3d (0, 0, 1);	glPushAttrib (GL_LIST_BIT);	// glListBase (fontbase);	char buf[20];	for (int i = 1; i <= mesh->GetNSeg(); i++)	  {//.........这里部分代码省略.........

/** * Apply fog to a span of RGBA pixels. * The fog value are either in the span->array->fog array or interpolated from * the fog/fogStep values. * They fog values are either fog coordinates (Z) or fog blend factors. * _PreferPixelFog should be in sync with that state! */void_swrast_fog_rgba_span( const struct gl_context *ctx, SWspan *span ){   const SWcontext *swrast = CONST_SWRAST_CONTEXT(ctx);   GLfloat rFog, gFog, bFog;   ASSERT(swrast->_FogEnabled);   ASSERT(span->arrayMask & SPAN_RGBA);   /* compute (scaled) fog color */   if (span->array->ChanType == GL_UNSIGNED_BYTE) {      rFog = ctx->Fog.Color[RCOMP] * 255.0F;      gFog = ctx->Fog.Color[GCOMP] * 255.0F;      bFog = ctx->Fog.Color[BCOMP] * 255.0F;   }   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {      rFog = ctx->Fog.Color[RCOMP] * 65535.0F;      gFog = ctx->Fog.Color[GCOMP] * 65535.0F;      bFog = ctx->Fog.Color[BCOMP] * 65535.0F;   }   else {      rFog = ctx->Fog.Color[RCOMP];      gFog = ctx->Fog.Color[GCOMP];      bFog = ctx->Fog.Color[BCOMP];   }   if (swrast->_PreferPixelFog) {      /* The span's fog values are fog coordinates, now compute blend factors       * and blend the fragment colors with the fog color.       */      switch (ctx->Fog.Mode) {      case GL_LINEAR:         {            const GLfloat fogEnd = ctx->Fog.End;            const GLfloat fogScale = (ctx->Fog.Start == ctx->Fog.End)               ? 1.0F : 1.0F / (ctx->Fog.End - ctx->Fog.Start);            if (span->array->ChanType == GL_UNSIGNED_BYTE) {               GLubyte (*rgba)[4] = span->array->rgba8;               FOG_LOOP(GLubyte, LINEAR_FOG);            }            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {               GLushort (*rgba)[4] = span->array->rgba16;               FOG_LOOP(GLushort, LINEAR_FOG);            }            else {               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL];               ASSERT(span->array->ChanType == GL_FLOAT);               FOG_LOOP(GLfloat, LINEAR_FOG);            }         }         break;      case GL_EXP:         {            const GLfloat density = -ctx->Fog.Density;            if (span->array->ChanType == GL_UNSIGNED_BYTE) {               GLubyte (*rgba)[4] = span->array->rgba8;               FOG_LOOP(GLubyte, EXP_FOG);            }            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {               GLushort (*rgba)[4] = span->array->rgba16;               FOG_LOOP(GLushort, EXP_FOG);            }            else {               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL];               ASSERT(span->array->ChanType == GL_FLOAT);               FOG_LOOP(GLfloat, EXP_FOG);            }         }         break;      case GL_EXP2:         {            const GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;            if (span->array->ChanType == GL_UNSIGNED_BYTE) {               GLubyte (*rgba)[4] = span->array->rgba8;               FOG_LOOP(GLubyte, EXP2_FOG);            }            else if (span->array->ChanType == GL_UNSIGNED_SHORT) {               GLushort (*rgba)[4] = span->array->rgba16;               FOG_LOOP(GLushort, EXP2_FOG);            }            else {               GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL];               ASSERT(span->array->ChanType == GL_FLOAT);               FOG_LOOP(GLfloat, EXP2_FOG);            }         }         break;      default:         _mesa_problem(ctx, "Bad fog mode in _swrast_fog_rgba_span");         return;//.........这里部分代码省略.........

void GLLineIlluminator::enableLighting(GLContextData& contextData) const	{	/* Get a pointer to the context data item: */	DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);		/* Update the material texture if it is outdated: */	if(dataItem->materialVersion!=materialVersion)		updateMaterial(dataItem);		GLenum previousMatrixMode=glGet<GLint>(GL_MATRIX_MODE);		Geometry::Matrix<GLfloat,4,4> modelView;	if(autoViewDirection||autoLightDirection)		{		/* Get the modelview matrix from OpenGL: */		GLfloat matrixArray[16];		glGetFloatv(GL_MODELVIEW_MATRIX,matrixArray);		modelView=Geometry::Matrix<GLfloat,4,4>::fromColumnMajor(matrixArray);		}		/* Determine the view direction: */	Geometry::ComponentArray<GLfloat,3> viewDir(viewDirection.getXyzw());	if(autoViewDirection)		{		/* Get the projection matrix from OpenGL: */		GLfloat matrixArray[16];		glGetFloatv(GL_PROJECTION_MATRIX,matrixArray);		Geometry::Matrix<GLfloat,4,4> projection=Geometry::Matrix<GLfloat,4,4>::fromColumnMajor(matrixArray);				/* Calculate the view direction from the OpenGL projection and modelview matrices: */		Geometry::ComponentArray<GLfloat,4> viewPos(0.0f,0.0f,1.0f,0.0f);		viewPos=viewPos/projection;		viewPos=viewPos/modelView;				/* Check if it's an orthogonal or perspective projection: */		if(Math::abs(viewPos[3])<1.0e-8f)			{			/* Just copy the view direction: */			viewDir=viewPos;			}		else			{			/* Calculate the direction from the view point to the scene center: */			for(int i=0;i<3;++i)				viewDir[i]=viewPos[i]/viewPos[3]-sceneCenter[i];			}		GLfloat viewDirLen=GLfloat(Geometry::mag(viewDir));		for(int i=0;i<3;++i)			viewDir[i]/=viewDirLen;		}		/* Determine the light direction: */	Geometry::ComponentArray<GLfloat,3> lightDir(lightDirection.getXyzw());	if(autoLightDirection)		{		/* Query the light direction from OpenGL and transform it to model coordinates: */		Geometry::ComponentArray<GLfloat,4> lightPos;		glGetLightPosition(autoLightIndex,lightPos.getComponents());		lightPos=lightPos/modelView;				/* Check if it's a directional or point light: */		if(Math::abs(lightPos[3])<1.0e-8f)			{			/* Just copy the light direction: */			lightDir=lightPos;			}		else			{			/* Calculate the direction from the light source to the scene center: */			for(int i=0;i<3;++i)				lightDir[i]=lightPos[i]/lightPos[3]-sceneCenter[i];			}		GLfloat lightDirLen=GLfloat(Geometry::mag(lightDir));		for(int i=0;i<3;++i)			lightDir[i]/=lightDirLen;		}		/* Set up the OpenGL texture matrix: */	glMatrixMode(GL_TEXTURE);	glPushMatrix();	GLfloat matrix[4][4];	for(int j=0;j<3;++j)		{		matrix[j][0]=lightDir[j];		matrix[j][1]=viewDir[j];		matrix[j][2]=0.0f;		matrix[j][3]=0.0f;		}	matrix[3][0]=1.0f;	matrix[3][1]=1.0f;	matrix[3][2]=0.0f;	matrix[3][3]=2.0f;	glLoadMatrixf((const GLfloat*)matrix);		/* Set the OpenGL rendering mode: */	glPushAttrib(GL_TEXTURE_BIT);	glBindTexture(GL_TEXTURE_2D,dataItem->materialTextureId);	glEnable(GL_TEXTURE_2D);	if(dataItem->materialType==INTENSITY)		glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);//.........这里部分代码省略.........

/* * RGBA copypixels with convolution. */static voidcopy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,                      GLint width, GLint height, GLint destx, GLint desty){   SWcontext *swrast = SWRAST_CONTEXT(ctx);   struct gl_renderbuffer *drawRb = NULL;   GLboolean quick_draw;   GLint row;   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;   const GLuint transferOps = ctx->_ImageTransferState;   GLfloat *dest, *tmpImage, *convImage;   struct sw_span span;   INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA);   if (ctx->Depth.Test)      _swrast_span_default_z(ctx, &span);   if (swrast->_FogEnabled)      _swrast_span_default_fog(ctx, &span);   if (SWRAST_CONTEXT(ctx)->_RasterMask == 0       && !zoom       && destx >= 0       && destx + width <= (GLint) ctx->DrawBuffer->Width) {      quick_draw = GL_TRUE;      drawRb = ctx->DrawBuffer->_ColorDrawBuffers[0][0];   }   else {      quick_draw = GL_FALSE;   }   /* allocate space for GLfloat image */   tmpImage = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));   if (!tmpImage) {      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");      return;   }   convImage = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));   if (!convImage) {      _mesa_free(tmpImage);      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");      return;   }   /* read source image */   dest = tmpImage;   for (row = 0; row < height; row++) {      GLchan rgba[MAX_WIDTH][4];      /* Read GLchan and convert to GLfloat */      _swrast_read_rgba_span(ctx, ctx->ReadBuffer->_ColorReadBuffer,                             width, srcx, srcy + row, rgba);      chan_span_to_float(width, (CONST GLchan (*)[4]) rgba,                         (GLfloat (*)[4]) dest);      dest += 4 * width;   }   /* do the image transfer ops which preceed convolution */   for (row = 0; row < height; row++) {      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (tmpImage + row * width * 4);      _mesa_apply_rgba_transfer_ops(ctx,                                    transferOps & IMAGE_PRE_CONVOLUTION_BITS,                                    width, rgba);   }   /* do convolution */   if (ctx->Pixel.Convolution2DEnabled) {      _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);   }   else {      ASSERT(ctx->Pixel.Separable2DEnabled);      _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);   }   _mesa_free(tmpImage);   /* do remaining post-convolution image transfer ops */   for (row = 0; row < height; row++) {      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (convImage + row * width * 4);      _mesa_apply_rgba_transfer_ops(ctx,                                    transferOps & IMAGE_POST_CONVOLUTION_BITS,                                    width, rgba);   }   /* write the new image */   for (row = 0; row < height; row++) {      const GLfloat *src = convImage + row * width * 4;      GLint dy;      /* convert floats back to chan */      float_span_to_chan(width, (const GLfloat (*)[4]) src, span.array->rgba);      /* write row to framebuffer */      dy = desty + row;      if (quick_draw && dy >= 0 && dy < (GLint) ctx->DrawBuffer->Height) {         drawRb->PutRow(ctx, drawRb, width, destx, dy, span.array->rgba, NULL);      }      else {//.........这里部分代码省略.........

// Handles the reshape event by setting the viewport so that it takes up the// whole visible region, then sets the projection matrix to something reason-// able that maintains proper aspect ratio.void reshape(GLint w, GLint h) {  glViewport(0, 0, w, h);  glMatrixMode(GL_PROJECTION);  glLoadIdentity();  gluPerspective(65.0, GLfloat(w)/GLfloat(h), 1.0, 20.0);}

void WaterRenderer::render(const PTransform& projection,const OGTransform& modelview,GLContextData& contextData) const	{	/* Get the data item: */	DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);		/* Calculate the required matrices: */	PTransform projectionModelview=projection;	projectionModelview*=modelview;		/* Bind the water rendering shader: */	glUseProgramObjectARB(dataItem->waterShader);	const GLint* ulPtr=dataItem->waterShaderUniforms;		/* Bind the water quantity texture: */	glActiveTextureARB(GL_TEXTURE0_ARB);	waterTable->bindQuantityTexture(contextData);	glUniform1iARB(*(ulPtr++),0);		/* Bind the bathymetry texture: */	glActiveTextureARB(GL_TEXTURE1_ARB);	waterTable->bindBathymetryTexture(contextData);	glUniform1iARB(*(ulPtr++),1);		/* Calculate and upload the vertex transformation from grid space to eye space: */	PTransform modelviewGridTransform=gridTransform;	modelviewGridTransform.leftMultiply(modelview);	glUniformARB(*(ulPtr++),modelviewGridTransform);		/* Calculate the transposed tangent plane transformation from grid space to eye space: */	PTransform tangentModelviewGridTransform=tangentGridTransform;	tangentModelviewGridTransform*=Geometry::invert(modelview);		/* Transpose and upload the transposed tangent plane transformation: */	const Scalar* tmvgtPtr=tangentModelviewGridTransform.getMatrix().getEntries();	GLfloat tangentModelviewGridTransformMatrix[16];	GLfloat* tmvgtmPtr=tangentModelviewGridTransformMatrix;	for(int i=0;i<16;++i,++tmvgtPtr,++tmvgtmPtr)		*tmvgtmPtr=GLfloat(*tmvgtPtr);	glUniformMatrix4fvARB(*(ulPtr++),1,GL_FALSE,tangentModelviewGridTransformMatrix);		/* Calculate and upload the vertex transformation from grid space to clip space: */	PTransform projectionModelviewGridTransform=gridTransform;	projectionModelviewGridTransform.leftMultiply(modelview);	projectionModelviewGridTransform.leftMultiply(projection);	glUniformARB(*(ulPtr++),projectionModelviewGridTransform);		/* Bind the vertex and index buffers: */	glBindBufferARB(GL_ARRAY_BUFFER_ARB,dataItem->vertexBuffer);	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,dataItem->indexBuffer);		/* Draw the surface: */	GLVertexArrayParts::enable(Vertex::getPartsMask());	glVertexPointer(static_cast<const Vertex*>(0));	GLuint* indexPtr=0;	for(unsigned int y=1;y<waterGridSize[1];++y,indexPtr+=waterGridSize[0]*2)		glDrawElements(GL_QUAD_STRIP,waterGridSize[0]*2,GL_UNSIGNED_INT,indexPtr);	GLVertexArrayParts::disable(Vertex::getPartsMask());		/* Unbind all textures and buffers: */	glBindBufferARB(GL_ARRAY_BUFFER_ARB,0);	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0);	glBindTexture(GL_TEXTURE_RECTANGLE_ARB,0);	glActiveTextureARB(GL_TEXTURE0_ARB);	glBindTexture(GL_TEXTURE_RECTANGLE_ARB,0);		/* Unbind the water rendering shader: */	glUseProgramObjectARB(0);	}

void TextureBlitter::drawTexture(int textureId, const QRectF &targetRect, const QSize &targetSize, int depth, bool targethasInvertedY, bool sourceHasInvertedY){    glViewport(0,0,targetSize.width(),targetSize.height());    GLfloat zValue = depth / 1000.0f;    //Set Texture and Vertex coordinates    const GLfloat textureCoordinates[] = {        0, 0,        1, 0,        1, 1,        0, 1    };    GLfloat x1 = targetRect.left();    GLfloat x2 = targetRect.right();    GLfloat y1, y2;    if (targethasInvertedY) {        if (sourceHasInvertedY) {            y1 = targetRect.top();            y2 = targetRect.bottom();        } else {            y1 = targetRect.bottom();            y2 = targetRect.top();        }    } else {        if (sourceHasInvertedY) {            y1 = targetSize.height() - targetRect.top();            y2 = targetSize.height() - targetRect.bottom();        } else {            y1 = targetSize.height() - targetRect.bottom();            y2 = targetSize.height() - targetRect.top();        }    }    const GLfloat vertexCoordinates[] = {        GLfloat(x1), GLfloat(y1), zValue,        GLfloat(x2), GLfloat(y1), zValue,        GLfloat(x2), GLfloat(y2), zValue,        GLfloat(x1), GLfloat(y2), zValue    };    //Set matrix to transfrom geometry values into gl coordinate space.    m_transformMatrix.setToIdentity();    m_transformMatrix.scale( 2.0f / targetSize.width(), 2.0f / targetSize.height() );    m_transformMatrix.translate(-targetSize.width() / 2.0f, -targetSize.height() / 2.0f);    //attach the data!    QOpenGLContext *currentContext = QOpenGLContext::currentContext();    currentContext->functions()->glEnableVertexAttribArray(m_vertexCoordEntry);    currentContext->functions()->glEnableVertexAttribArray(m_textureCoordEntry);    currentContext->functions()->glVertexAttribPointer(m_vertexCoordEntry, 3, GL_FLOAT, GL_FALSE, 0, vertexCoordinates);    currentContext->functions()->glVertexAttribPointer(m_textureCoordEntry, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinates);    m_shaderProgram->setUniformValue(m_matrixLocation, m_transformMatrix);    glBindTexture(GL_TEXTURE_2D, textureId);    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);    glBindTexture(GL_TEXTURE_2D, 0);    currentContext->functions()->glDisableVertexAttribArray(m_vertexCoordEntry);    currentContext->functions()->glDisableVertexAttribArray(m_textureCoordEntry);}

Vector Vector::operator/(const GLfloat & r){	Vector tmp(*this);	tmp = tmp * (GLfloat(1) / r);	return tmp;}

void Globe::load_mapdata(string mapname, int lat, int lng) {    if (DEBUG) cout << "Loading map " << mapname << endl;    ifstream file(mapname.c_str(), std::ios::in | std::ios::binary);    short heights[map_size][map_size];    if(!file) {        cout << "Error opening file: " << mapname << endl;    } else {        unsigned char buffer[2];        for (int i = map_size-1; i >= 0; i--) {            for (int j = 0; j < map_size; j++) {                if(!file.read( reinterpret_cast<char*>(buffer), sizeof(buffer) )) {                    cout << "Error reading file: " << mapname << endl;                }                heights[j][i] = (buffer[0] << 8) | buffer[1]; // zamieniamy bajty            }        }    }    // ponizsze ladowanie mozna przeniesc wyzej    GLfloat tmpa, tmpb;    GLfloat tmph;    GLfloat tlat, tlng;    vsize = engine->vertices.size();    for (int j = 0; j < map_size; j++) {        for (int i = 0; i < map_size; i++) {            if (engine->current_mode == 3) {                tmpa = lat + j * DEGREES;                tmpb = lng + i * DEGREES;                tmph = GLfloat (heights[i][j]);            } else {                tmpa = lng * 1200 + i;                tmpb = lat * 1200 + j;//                tmpa = lng * ANGLES;//                tmpb = log(tan((lat * ANGLES) / 2));                tmph = GLfloat (heights[i][j]);                if (i % 1201 == 0 && j % 1201 == 0) cout << "V(" << tmpa << ", " << tmpb << ", " << tmph << ") [" << lng << ", " << lat << "]/n";            }            engine->vertices.push_back({                tmpa, tmpb, tmph            });        }    }    // tworzenie trójk
C++ GLimp_LogComment函数代码示例
C++ GLevelEditorModeTools函数代码示例