开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
lodspheremesh.cpp
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：26k
源码类别：

OpenGL

开发平台：

Visual C++

lodspheremesh.cpp：源码内容
  1. // lodspheremesh.cpp
  2. //
  3. // Copyright (C) 2000-2007, Chris Laurel <claurel@shatters.net>
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  10. #include <cmath>
  11. #include <cassert>
  12. #include <iostream>
  13. #include <algorithm>
  14. #include <celmath/mathlib.h>
  15. #include <celmath/vecmath.h>
  16. #include "gl.h"
  17. #include "glext.h"
  18. #include "vecgl.h"
  19. #include "lodspheremesh.h"
  21. using namespace std;
  23. //#define SHOW_PATCH_VISIBILITY
  24. //#define SHOW_FRUSTUM
  25. //#define VERTEX_BUFFER_OBJECTS_ENABLED
  27. static bool trigArraysInitialized = false;
  28. static int maxDivisions = 16384;
  29. static int thetaDivisions = maxDivisions;
  30. static int phiDivisions = maxDivisions / 2;
  31. static int minStep = 128;
  32. static float* sinPhi = NULL;
  33. static float* cosPhi = NULL;
  34. static float* sinTheta = NULL;
  35. static float* cosTheta = NULL;
  37. // largest vertex:
  38. //     position   - 3 floats,
  39. //     normal     - 3 floats,
  40. //     tangent    - 3 floats,
  41. //     tex coords - 2 floats * MAX_SPHERE_MESH_TEXTURES
  42. static int MaxVertexSize = 3 + 3 + 3 + MAX_SPHERE_MESH_TEXTURES * 2;
  44. #ifdef SHOW_PATCH_VISIBILITY
  45. static const int MaxPatchesShown = 4096;
  46. static int visiblePatches[MaxPatchesShown];
  47. #endif
  50. static void InitTrigArrays()
  51. {
  52.     sinTheta = new float[thetaDivisions + 1];
  53.     cosTheta = new float[thetaDivisions + 1];
  54.     sinPhi = new float[phiDivisions + 1];
  55.     cosPhi = new float[phiDivisions + 1];
  57.     int i;
  58.     for (i = 0; i <= thetaDivisions; i++)
  59.     {
  60.         double theta = (double) i / (double) thetaDivisions * 2.0 * PI;
  61.         sinTheta[i] = (float) sin(theta);
  62.         cosTheta[i] = (float) cos(theta);
  63.     }
  65.     for (i = 0; i <= phiDivisions; i++)
  66.     {
  67.         double phi = ((double) i / (double) phiDivisions - 0.5) * PI;
  68.         sinPhi[i] = (float) sin(phi);
  69.         cosPhi[i] = (float) cos(phi);
  70.     }
  72.     trigArraysInitialized = true;
  73. }
  76. static float getSphereLOD(float discSizeInPixels)
  77. {
  78.     if (discSizeInPixels < 10)
  79.         return -3.0f;
  80.     else if (discSizeInPixels < 20)
  81.         return -2.0f;
  82.     else if (discSizeInPixels < 50)
  83.         return -1.0f;
  84.     else if (discSizeInPixels < 200)
  85.         return 0.0f;
  86.     else if (discSizeInPixels < 1200)
  87.         return 1.0f;
  88.     else if (discSizeInPixels < 7200)
  89.         return 2.0f;
  90.     else if (discSizeInPixels < 53200)
  91.         return 3.0f;
  92.     else
  93.         return 4.0f;
  94. }
  97. LODSphereMesh::LODSphereMesh() :
  98.     vertices(NULL),
  99.     vertexBuffersInitialized(false),
  100.     useVertexBuffers(false)
  101. {
  102.     if (!trigArraysInitialized)
  103.         InitTrigArrays();
  105.     int maxThetaSteps = thetaDivisions / minStep;
  106.     int maxPhiSteps = phiDivisions / minStep;
  107.     maxVertices = (maxPhiSteps + 1) * (maxThetaSteps + 1);
  108.     vertices = new float[MaxVertexSize * maxVertices];
  110.     nIndices = maxPhiSteps * 2 * (maxThetaSteps + 1);
  111.     indices = new unsigned short[nIndices];
  112. }
  115. LODSphereMesh::~LODSphereMesh()
  116. {
  117.     if (vertices != NULL)
  118.         delete[] vertices;
  119. }
  122. static Point3f spherePoint(int theta, int phi)
  123. {
  124.     return Point3f(cosPhi[phi] * cosTheta[theta],
  125.                    sinPhi[phi],
  126.                    cosPhi[phi] * sinTheta[theta]);
  127. }
  130. void LODSphereMesh::render(const GLContext& context,
  131.                            const Frustum& frustum,
  132.                            float pixWidth,
  133.                            Texture** tex,
  134.                            int nTextures)
  135. {
  136.     render(context,
  137.            Normals | TexCoords0, frustum, pixWidth, tex,
  138.            nTextures);
  139. }
  142. void LODSphereMesh::render(const GLContext& context,
  143.                            unsigned int attributes,
  144.                            const Frustum& frustum,
  145.                            float pixWidth,
  146.                            Texture* tex0,
  147.                            Texture* tex1,
  148.                            Texture* tex2,
  149.                            Texture* tex3)
  150. {
  151.     Texture* textures[MAX_SPHERE_MESH_TEXTURES];
  152.     int nTextures = 0;
  154.     if (tex0 != NULL)
  155.         textures[nTextures++] = tex0;
  156.     if (tex1 != NULL)
  157.         textures[nTextures++] = tex1;
  158.     if (tex2 != NULL)
  159.         textures[nTextures++] = tex2;
  160.     if (tex3 != NULL)
  161.         textures[nTextures++] = tex3;
  162.     render(context, attributes, frustum, pixWidth, textures, nTextures);
  163. }
  166. void LODSphereMesh::render(const GLContext& context,
  167.                            unsigned int attributes,
  168.                            const Frustum& frustum,
  169.                            float pixWidth,
  170.                            Texture** tex,
  171.                            int nTextures)
  172. {
  173.     int lod = 64;
  174.     float lodBias = getSphereLOD(pixWidth);
  176.     if (lodBias < 0.0f)
  177.     {
  178.         if (lodBias < -30)
  179.             lodBias = -30;
  180.         lod = lod / (1 << (int) (-lodBias));
  181.         if (lod < 2)
  182.             lod = 2;
  183.     }
  184.     else if (lodBias > 0.0f)
  185.     {
  186.         if (lodBias > 30)
  187.             lodBias = 30;
  188.         lod = lod * (1 << (int) lodBias);
  189.         if (lod > maxDivisions)
  190.             lod = maxDivisions;
  191.     }
  193.     int step = maxDivisions / lod;
  194.     int thetaExtent = maxDivisions;
  195.     int phiExtent = thetaExtent / 2;
  197.     int split = 1;
  198.     if (step < minStep)
  199.     {
  200.         split = minStep / step;
  201.         thetaExtent /= split;
  202.         phiExtent /= split;
  203.     }
  205.     if (tex == NULL)
  206.         nTextures = 0;
  209.     // Need to have vertex programs enabled in order to make
  210.     // use of surface tangents.
  211.     if (!context.getVertexProcessor())
  212.         attributes &= ~Tangents;
  214.     RenderInfo ri(step, attributes, frustum, context);
  216.     // If one of the textures is split into subtextures, we may have to
  217.     // use extra patches, since there can be at most one subtexture per patch.
  218.     int i;
  219.     int minSplit = 1;
  220.     for (i = 0; i < nTextures; i++)
  221.     {
  222.         float pixelsPerTexel = pixWidth * 2.0f /
  223.             ((float) tex[i]->getWidth() / 2.0f);
  224.         double l = log(pixelsPerTexel) / log(2.0);
  226.         ri.texLOD[i] = max(min(tex[i]->getLODCount() - 1, (int) l), 0);
  227.         if (tex[i]->getUTileCount(ri.texLOD[i]) > minSplit)
  228.             minSplit = tex[i]->getUTileCount(ri.texLOD[i]);
  229.         if (tex[i]->getVTileCount(ri.texLOD[i]) > minSplit)
  230.             minSplit = tex[i]->getVTileCount(ri.texLOD[i]);
  231.     }
  233.     if (split < minSplit)
  234.     {
  235.         thetaExtent /= (minSplit / split);
  236.         phiExtent /= (minSplit / split);
  237.         split = minSplit;
  238.         if (phiExtent <= ri.step)
  239.             ri.step /= ri.step / phiExtent;
  240.     }
  242.     // Set the current textures
  243.     nTexturesUsed = nTextures;
  244.     for (i = 0; i < nTextures; i++)
  245.     {
  246.         tex[i]->beginUsage();
  247.         textures[i] = tex[i];
  248.         subtextures[i] = 0;
  249.         if (nTextures > 1)
  250.             glx::glActiveTextureARB(GL_TEXTURE0_ARB + i);
  251.         glEnable(GL_TEXTURE_2D);
  252.     }
  254. #ifdef VERTEX_BUFFER_OBJECTS_ENABLED
  255.     if (!vertexBuffersInitialized)
  256.     {
  257.         // TODO: assumes that the same context is used every time we
  258.         // render.  Valid now, but not necessarily in the future.  Still,
  259.         // would only cause problems if we rendered in two different contexts
  260.         // and only one had vertex buffer objects.
  261.         vertexBuffersInitialized = true;
  262.         if (context.extensionSupported("GL_ARB_vertex_buffer_object"))
  263.         {
  264.             for (int i = 0; i < NUM_SPHERE_VERTEX_BUFFERS; i++)
  265.             {
  266.                 GLuint vbname = 0;
  267.                 glx::glGenBuffersARB(1, &vbname);
  268.                 vertexBuffers[i] = (unsigned int) vbname;
  269.                 glx::glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBuffers[i]);
  270.                 glx::glBufferDataARB(GL_ARRAY_BUFFER_ARB,
  271.                                      maxVertices * MaxVertexSize * sizeof(float),
  272.                                      NULL,
  273.                                      GL_STREAM_DRAW_ARB);
  274.             }
  275.             glx::glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  277.             glx::glGenBuffersARB(1, &indexBuffer);
  279.             useVertexBuffers = true;
  281.             // HACK: delete the user arrays--we shouldn't need to allocate
  282.             // these at all if we're using vertex buffer objects.
  283.             delete[] vertices;
  284.         }
  285.     }
  286. #endif
  288.     if (useVertexBuffers)
  289.     {
  290.         currentVB = 0;
  291.         glx::glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBuffers[currentVB]);
  292.     }
  294.     // Set up the mesh vertices
  295.     int nRings = phiExtent / ri.step;
  296.     int nSlices = thetaExtent / ri.step;
  298.     int n2 = 0;
  299.     for (i = 0; i < nRings; i++)
  300.     {
  301.         for (int j = 0; j <= nSlices; j++)
  302.         {
  303.             indices[n2 + 0] = i * (nSlices + 1) + j;
  304.             indices[n2 + 1] = (i + 1) * (nSlices + 1) + j;
  305.             n2 += 2;
  306.         }
  307.     }
  309.     if (useVertexBuffers)
  310.     {
  311.         glx::glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexBuffer);
  312.         glx::glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
  313.                              nIndices * sizeof(indices[0]),
  314.                              indices,
  315.                              GL_DYNAMIC_DRAW_ARB);
  316.     }
  318.     // Compute the size of a vertex
  319.     vertexSize = 3;
  320.     if ((attributes & Tangents) != 0)
  321.         vertexSize += 3;
  322.     for (i = 0; i < nTextures; i++)
  323.         vertexSize += 2;
  325.     glEnableClientState(GL_VERTEX_ARRAY);
  326.     if ((attributes & Normals) != 0)
  327.         glEnableClientState(GL_NORMAL_ARRAY);
  329.     for (i = 0; i < nTextures; i++)
  330.     {
  331.         if (nTextures > 1)
  332.             glx::glClientActiveTextureARB(GL_TEXTURE0_ARB + i);
  333.         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  334.     }
  336.     glDisableClientState(GL_COLOR_ARRAY);
  338.     if ((attributes & Tangents) != 0)
  339.     {
  340.         VertexProcessor* vproc = context.getVertexProcessor();
  341.         vproc->enableAttribArray(6);
  342.     }
  344.     if (split == 1)
  345.     {
  346.         renderSection(0, 0, thetaExtent, ri);
  347.     }
  348.     else
  349.     {
  350.         // Render the sphere section by section.
  351.         /*int reject = 0;   Unused*/
  353.         // Compute the vertices of the view frustum.  These will be used for
  354.         // culling patches.
  355.         ri.fp[0] = Planef::intersection(frustum.getPlane(Frustum::Near),
  356.                                         frustum.getPlane(Frustum::Top),
  357.                                         frustum.getPlane(Frustum::Left));
  358.         ri.fp[1] = Planef::intersection(frustum.getPlane(Frustum::Near),
  359.                                         frustum.getPlane(Frustum::Top),
  360.                                         frustum.getPlane(Frustum::Right));
  361.         ri.fp[2] = Planef::intersection(frustum.getPlane(Frustum::Near),
  362.                                         frustum.getPlane(Frustum::Bottom),
  363.                                         frustum.getPlane(Frustum::Left));
  364.         ri.fp[3] = Planef::intersection(frustum.getPlane(Frustum::Near),
  365.                                         frustum.getPlane(Frustum::Bottom),
  366.                                         frustum.getPlane(Frustum::Right));
  367.         ri.fp[4] = Planef::intersection(frustum.getPlane(Frustum::Far),
  368.                                         frustum.getPlane(Frustum::Top),
  369.                                         frustum.getPlane(Frustum::Left));
  370.         ri.fp[5] = Planef::intersection(frustum.getPlane(Frustum::Far),
  371.                                         frustum.getPlane(Frustum::Top),
  372.                                         frustum.getPlane(Frustum::Right));
  373.         ri.fp[6] = Planef::intersection(frustum.getPlane(Frustum::Far),
  374.                                         frustum.getPlane(Frustum::Bottom),
  375.                                         frustum.getPlane(Frustum::Left));
  376.         ri.fp[7] = Planef::intersection(frustum.getPlane(Frustum::Far),
  377.                                         frustum.getPlane(Frustum::Bottom),
  378.                                         frustum.getPlane(Frustum::Right));
  382. #ifdef SHOW_PATCH_VISIBILITY
  383.         {
  384.             for (int i = 0; i < MaxPatchesShown; i++)
  385.                 visiblePatches[i] = 0;
  386.         }
  387. #endif // SHOW_PATCH_VISIBILITY
  389.         int nPatches = 0;
  390.         {
  391.             int extent = maxDivisions / 2;
  393.             for (int i = 0; i < 2; i++)
  394.             {
  395.                 for (int j = 0; j < 2; j++)
  396.                 {
  397.                     nPatches += renderPatches(i * extent / 2, j * extent,
  398.                                               extent, split / 2, ri);
  399.                 }
  400.             }
  401.         }
  402.         // cout << "Rendered " << nPatches << " of " << square(split) << " patchesn";
  403.     }
  405.     glDisableClientState(GL_VERTEX_ARRAY);
  406.     if ((attributes & Normals) != 0)
  407.         glDisableClientState(GL_NORMAL_ARRAY);
  409.     if ((attributes & Tangents) != 0)
  410.     {
  411.         VertexProcessor* vproc = context.getVertexProcessor();
  412.         vproc->disableAttribArray(6);
  413.     }
  415.     for (i = 0; i < nTextures; i++)
  416.     {
  417.         tex[i]->endUsage();
  419.         if (nTextures > 1)
  420.         {
  421.             glx::glClientActiveTextureARB(GL_TEXTURE0_ARB + i);
  422.             glx::glActiveTextureARB(GL_TEXTURE0_ARB + i);
  423.         }
  424.         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  425.         if (i > 0)
  426.             glDisable(GL_TEXTURE_2D);
  427.     }
  429.     if (nTextures > 1)
  430.     {
  431.         glx::glClientActiveTextureARB(GL_TEXTURE0_ARB);
  432.         glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  433.     }
  435.     if (useVertexBuffers)
  436.     {
  437.         glx::glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  438.         glx::glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
  439.         vertices = NULL;
  440.     }
  442. #ifdef SHOW_FRUSTUM
  443.     // Debugging code for visualizing the frustum.
  444.     glMatrixMode(GL_PROJECTION);
  445.     glPushMatrix();
  446.     glLoadIdentity();
  447.     gluPerspective(45.0, 1.3333f, 1.0f, 100.0f);
  448.     glMatrixMode(GL_MODELVIEW);
  449.     glPushMatrix();
  450.     glLoadIdentity();
  451.     glDisable(GL_TEXTURE_2D);
  452.     glDisable(GL_LIGHTING);
  453.     glColor4f(1, 0, 0, 1);
  454.     glTranslatef(0, 0, -20);
  455.     glBegin(GL_LINES);
  456.     glVertex(ri.fp[0]); glVertex(ri.fp[1]);
  457.     glVertex(ri.fp[0]); glVertex(ri.fp[2]);
  458.     glVertex(ri.fp[3]); glVertex(ri.fp[1]);
  459.     glVertex(ri.fp[3]); glVertex(ri.fp[2]);
  460.     glVertex(ri.fp[4]); glVertex(ri.fp[5]);
  461.     glVertex(ri.fp[4]); glVertex(ri.fp[6]);
  462.     glVertex(ri.fp[7]); glVertex(ri.fp[5]);
  463.     glVertex(ri.fp[7]); glVertex(ri.fp[6]);
  464.     glVertex(ri.fp[0]); glVertex(ri.fp[4]);
  465.     glVertex(ri.fp[1]); glVertex(ri.fp[5]);
  466.     glVertex(ri.fp[2]); glVertex(ri.fp[6]);
  467.     glVertex(ri.fp[3]); glVertex(ri.fp[7]);
  468.     glEnd();
  470.     // Render axes representing the unit sphere.
  471.     glColor4f(0, 1, 0, 1);
  472.     glBegin(GL_LINES);
  473.     glVertex3f(-1, 0, 0); glVertex3f(1, 0, 0);
  474.     glVertex3f(0, -1, 0); glVertex3f(0, 1, 0);
  475.     glVertex3f(0, 0, -1); glVertex3f(1, 0, 1);
  476.     glEnd();
  477.     glMatrixMode(GL_PROJECTION);
  478.     glPopMatrix();
  479.     glMatrixMode(GL_MODELVIEW);
  480.     glPopMatrix();
  481. #endif
  483. #ifdef SHOW_PATCH_VISIBILITY
  484.     // Debugging code for visualizing the frustum.
  485.     glMatrixMode(GL_PROJECTION);
  486.     glPushMatrix();
  487.     glLoadIdentity();
  488.     glMatrixMode(GL_MODELVIEW);
  489.     glPushMatrix();
  490.     glLoadIdentity();
  491.     glDisable(GL_TEXTURE_2D);
  492.     glDisable(GL_LIGHTING);
  493.     glColor4f(1, 0, 1, 1);
  495.     {
  496.         int width = split;
  497.         int height = width / 2;
  498.         float patchWidth = 1.0f / (float) width;
  499.         float patchHeight = 1.0f / (float) height;
  500.         if (width * height <= MaxPatchesShown)
  501.         {
  502.             for (int i = 0; i < height; i++)
  503.             {
  504.                 for (int j = 0; j < width; j++)
  505.                 {
  506.                     glPushMatrix();
  507.                     glTranslatef(-0.5f + j * patchWidth,
  508.                                  1.0f - i * patchHeight,
  509.                                  0.0f);
  510.                     if (visiblePatches[i * width + j])
  511.                         glBegin(GL_QUADS);
  512.                     else
  513.                         glBegin(GL_LINE_LOOP);
  514.                     glVertex3f(0.0f, 0.0f, 0.0f);
  515.                     glVertex3f(0.0f, -patchHeight, 0.0f);
  516.                     glVertex3f(patchWidth, -patchHeight, 0.0f);
  517.                     glVertex3f(patchWidth, 0.0f, 0.0f);
  518.                     glEnd();
  519.                     glPopMatrix();
  520.                 }
  521.             }
  522.         }
  523.     }
  525.     glMatrixMode(GL_PROJECTION);
  526.     glPopMatrix();
  527.     glMatrixMode(GL_MODELVIEW);
  528.     glPopMatrix();
  529. #endif // SHOW_PATCH_VISIBILITY
  530. }
  533. int LODSphereMesh::renderPatches(int phi0, int theta0,
  534.                                  int extent,
  535.                                  int level,
  536.                                  const RenderInfo& ri)
  537. {
  538.     int thetaExtent = extent;
  539.     int phiExtent = extent / 2;
  541.     // Compute the plane separating this section of the sphere from
  542.     // the rest of the sphere.  If the view frustum lies entirely
  543.     // on the side of the plane that does not contain the sphere
  544.     // patch, we cull the patch.
  545.     Point3f p0 = spherePoint(theta0, phi0);
  546.     Point3f p1 = spherePoint(theta0 + thetaExtent, phi0);
  547.     Point3f p2 = spherePoint(theta0 + thetaExtent,
  548.                              phi0 + phiExtent);
  549.     Point3f p3 = spherePoint(theta0, phi0 + phiExtent);
  550.     Vec3f v0 = p1 - p0;
  551.     Vec3f v2 = p3 - p2;
  552.     Vec3f normal;
  553.     if (v0.lengthSquared() > v2.lengthSquared())
  554.         normal = (p0 - p3) ^ v0;
  555.     else
  556.         normal = (p2 - p1) ^ v2;
  558.     // If the normal is near zero length, something's going wrong
  559.     assert(normal.length() != 0.0f);
  560.     normal.normalize();
  561.     Planef separatingPlane(normal, p0);
  563.     bool outside = true;
  564. #if 1
  565.     for (int k = 0; k < 8; k++)
  566.     {
  567.         if (separatingPlane.distanceTo(ri.fp[k]) > 0.0f)
  568.         {
  569.             outside = false;
  570.             break;
  571.         }
  572.     }
  574.     // If this patch is outside the view frustum, so are all of its subpatches
  575.     if (outside)
  576.         return 0;
  577. #else
  578.     outside = false;
  579. #endif
  581.     // Second cull test uses the bounding sphere of the patch
  582. #if 0
  583.     // Is this a better choice for the patch center?
  584.     Point3f patchCenter = spherePoint(theta0 + thetaExtent / 2,
  585.                                       phi0 + phiExtent / 2);
  586. #else
  587.     // . . . or is the average of the points better?
  588.     Point3f patchCenter = Point3f(p0.x + p1.x + p2.x + p3.x,
  589.                                   p0.y + p1.y + p2.y + p3.y,
  590.                                   p0.z + p1.z + p2.z + p3.z) * 0.25f;
  591. #endif
  592.     float boundingRadius = 0.0f;
  593.     boundingRadius = max(boundingRadius, patchCenter.distanceTo(p0));
  594.     boundingRadius = max(boundingRadius, patchCenter.distanceTo(p1));
  595.     boundingRadius = max(boundingRadius, patchCenter.distanceTo(p2));
  596.     boundingRadius = max(boundingRadius, patchCenter.distanceTo(p3));
  597.     if (ri.frustum.testSphere(patchCenter, boundingRadius) == Frustum::Outside)
  598.         outside = true;
  600.     if (outside)
  601.     {
  602.         return 0;
  603.     }
  604.     else if (level == 1)
  605.     {
  606.         renderSection(phi0, theta0, thetaExtent, ri);
  607.         return 1;
  608.     }
  609.     else
  610.     {
  611.         int nRendered = 0;
  612.         for (int i = 0; i < 2; i++)
  613.         {
  614.             for (int j = 0; j < 2; j++)
  615.             {
  616.                 nRendered += renderPatches(phi0 + phiExtent / 2 * i,
  617.                                            theta0 + thetaExtent / 2 * j,
  618.                                            extent / 2,
  619.                                            level / 2,
  620.                                            ri);
  621.             }
  622.         }
  623.         return nRendered;
  624.     }
  625. }
  628. void LODSphereMesh::renderSection(int phi0, int theta0, int extent,
  629.                                   const RenderInfo& ri)
  631. {
  632. #ifdef SHOW_PATCH_VISIBILITY
  633.     {
  634.         int width = thetaDivisions / extent;
  635.         int height = phiDivisions / extent;
  636.         int x = theta0 / extent;
  637.         int y = phi0 / extent;
  638.         if (width * height <= MaxPatchesShown)
  639.             visiblePatches[y * width + x] = 1;
  640.     }
  641. #endif // SHOW_PATCH_VISIBILITY
  643.     GLsizei stride = (GLsizei) (vertexSize * sizeof(float));
  644.     int tangentOffset = 3;
  645.     int texCoordOffset = ((ri.attributes & Tangents) != 0) ? 6 : 3;
  646.     float* vertexBase = useVertexBuffers ? (float*) NULL : vertices;
  648.     glVertexPointer(3, GL_FLOAT, stride, vertexBase + 0);
  649.     if ((ri.attributes & Normals) != 0)
  650.         glNormalPointer(GL_FLOAT, stride, vertexBase);
  652.     for (int tc = 0; tc < nTexturesUsed; tc++)
  653.     {
  654.         if (nTexturesUsed > 1)
  655.             glx::glClientActiveTextureARB(GL_TEXTURE0_ARB + tc);
  656.         glTexCoordPointer(2, GL_FLOAT, stride,  vertexBase + (tc * 2) + texCoordOffset);
  657.     }
  659.     if ((ri.attributes & Tangents) != 0)
  660.     {
  661.         VertexProcessor* vproc = ri.context.getVertexProcessor();
  662.         vproc->attribArray(6, 3, GL_FLOAT, stride, vertexBase + tangentOffset);
  663.     }
  665.     // assert(ri.step >= minStep);
  666.     // assert(phi0 + extent <= maxDivisions);
  667.     // assert(theta0 + extent / 2 < maxDivisions);
  668.     // assert(isPow2(extent));
  669.     int thetaExtent = extent;
  670.     int phiExtent = extent / 2;
  671.     int theta1 = theta0 + thetaExtent;
  672.     int phi1 = phi0 + phiExtent;
  673.     /*int n3 = 0;   Unused*/
  674.     /*int n2 = 0;   Unused*/
  676.     float du[MAX_SPHERE_MESH_TEXTURES];
  677.     float dv[MAX_SPHERE_MESH_TEXTURES];
  678.     float u0[MAX_SPHERE_MESH_TEXTURES];
  679.     float v0[MAX_SPHERE_MESH_TEXTURES];
  682.     if (useVertexBuffers)
  683.     {
  684.         // Calling glBufferDataARB() with NULL before mapping the buffer
  685.         // is a hint to OpenGL that previous contents of vertex buffer will
  686.         // be discarded and overwritten. It enables renaming in the driver,
  687.         // hopefully resulting in performance gains.
  688.         glx::glBufferDataARB(GL_ARRAY_BUFFER_ARB,
  689.                              maxVertices * vertexSize * sizeof(float),
  690.                              NULL,
  691.                              GL_STREAM_DRAW_ARB);
  693.         vertices = reinterpret_cast<float*>(glx::glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB));
  694.         if (vertices == NULL)
  695.             return;
  696.     }
  698.     // Set the current texture.  This is necessary because the texture
  699.     // may be split into subtextures.
  700.     for (int tex = 0; tex < nTexturesUsed; tex++)
  701.     {
  702.         du[tex] = (float) 1.0f / thetaDivisions;;
  703.         dv[tex] = (float) 1.0f / phiDivisions;;
  704.         u0[tex] = 1.0f;
  705.         v0[tex] = 1.0f;
  707.         if (textures[tex] != NULL)
  708.         {
  709.             int uTexSplit = textures[tex]->getUTileCount(ri.texLOD[tex]);
  710.             int vTexSplit = textures[tex]->getVTileCount(ri.texLOD[tex]);
  711.             int patchSplit = maxDivisions / extent;
  712.             assert(patchSplit >= uTexSplit && patchSplit >= vTexSplit);
  714.             int u = theta0 / thetaExtent;
  715.             int v = phi0 / phiExtent;
  716.             int patchesPerUSubtex = patchSplit / uTexSplit;
  717.             int patchesPerVSubtex = patchSplit / vTexSplit;
  719.             du[tex] *= uTexSplit;
  720.             dv[tex] *= vTexSplit;
  721.             u0[tex] = 1.0f - ((float) (u % patchesPerUSubtex) /
  722.                               (float) patchesPerUSubtex);
  723.             v0[tex] = 1.0f - ((float) (v % patchesPerVSubtex) /
  724.                               (float) patchesPerVSubtex);
  725.             u0[tex] += theta0 * du[tex];
  726.             v0[tex] += phi0 * dv[tex];
  728.             u /= patchesPerUSubtex;
  729.             v /= patchesPerVSubtex;
  731.             if (nTexturesUsed > 1)
  732.                 glx::glActiveTextureARB(GL_TEXTURE0_ARB + tex);
  733.             TextureTile tile = textures[tex]->getTile(ri.texLOD[tex],
  734.                                                       uTexSplit - u - 1,
  735.                                                       vTexSplit - v - 1);
  736.             du[tex] *= tile.du;
  737.             dv[tex] *= tile.dv;
  738.             u0[tex] = u0[tex] * tile.du + tile.u;
  739.             v0[tex] = v0[tex] * tile.dv + tile.v;
  741.             // We track the current texture to avoid unnecessary and costly
  742.             // texture state changes.
  743.             if (tile.texID != subtextures[tex])
  744.             {
  745.                 glBindTexture(GL_TEXTURE_2D, tile.texID);
  746.                 subtextures[tex] = tile.texID;
  747.             }
  748.         }
  749.     }
  751.     int vindex = 0;
  752.     for (int phi = phi0; phi <= phi1; phi += ri.step)
  753.     {
  754.         float cphi = cosPhi[phi];
  755.         float sphi = sinPhi[phi];
  757.         if ((ri.attributes & Tangents) != 0)
  758.         {
  759.             for (int theta = theta0; theta <= theta1; theta += ri.step)
  760.             {
  761.                 float ctheta = cosTheta[theta];
  762.                 float stheta = sinTheta[theta];
  764.                 vertices[vindex]      = cphi * ctheta;
  765.                 vertices[vindex + 1]  = sphi;
  766.                 vertices[vindex + 2]  = cphi * stheta;
  768.                 // Compute the tangent--required for bump mapping
  769.                 vertices[vindex + 3] = stheta;
  770.                 vertices[vindex + 4] = 0.0f;
  771.                 vertices[vindex + 5] = -ctheta;
  773.                 vindex += 6;
  775.                 for (int tex = 0; tex < nTexturesUsed; tex++)
  776.                 {
  777.                     vertices[vindex]     = u0[tex] - theta * du[tex];
  778.                     vertices[vindex + 1] = v0[tex] - phi * dv[tex];
  779.                     vindex += 2;
  780.                 }
  781.             }
  782.         }
  783.         else
  784.         {
  785.             for (int theta = theta0; theta <= theta1; theta += ri.step)
  786.             {
  787.                 float ctheta = cosTheta[theta];
  788.                 float stheta = sinTheta[theta];
  790.                 vertices[vindex]      = cphi * ctheta;
  791.                 vertices[vindex + 1]  = sphi;
  792.                 vertices[vindex + 2]  = cphi * stheta;
  794.                 vindex += 3;
  796.                 for (int tex = 0; tex < nTexturesUsed; tex++)
  797.                 {
  798.                     vertices[vindex]     = u0[tex] - theta * du[tex];
  799.                     vertices[vindex + 1] = v0[tex] - phi * dv[tex];
  800.                     vindex += 2;
  801.                 }
  802.             }
  803.         }
  804.     }
  806.     if (useVertexBuffers)
  807.     {
  808.         vertices = NULL;
  809.         if (!glx::glUnmapBufferARB(GL_ARRAY_BUFFER_ARB))
  810.             return;
  811.     }
  813.     // TODO: Fix this--number of rings can reach zero and cause dropout
  814.     // int nRings = max(phiExtent / ri.step, 1); // buggy
  815.     int nRings = phiExtent / ri.step;
  816.     int nSlices = thetaExtent / ri.step;
  817.     unsigned short* indexBase = useVertexBuffers ? (unsigned short*) NULL : indices;
  818.     for (int i = 0; i < nRings; i++)
  819.     {
  820.         glDrawElements(GL_QUAD_STRIP,
  821.                        (nSlices + 1) * 2,
  822.                        GL_UNSIGNED_SHORT,
  823.                        indexBase + (nSlices + 1) * 2 * i);
  824.     }
  826.     // Cycle through the vertex buffers
  827.     if (useVertexBuffers)
  828.     {
  829.         currentVB++;
  830.         if (currentVB == NUM_SPHERE_VERTEX_BUFFERS)
  831.             currentVB = 0;
  832.         glx::glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBuffers[currentVB]);
  833.     }
  834. }