不使用 gluSphere() 在 OpenGL 中绘制球体？

Question

有没有教程解释如何在 OpenGL 中绘制球体而无需使用 gluSphere() ？

许多 OpenGL 3D 教程都只是关于立方体。我已经搜索过，但大多数绘制球体的解决方案都是使用 gluSphere() 。还有一个网站有绘制球体的代码 这个网站，但它没有解释绘制球体背后的数学原理。我还有其他版本的如何在多边形中绘制球体而不是该链接中的四边形。但同样，我不明白如何用代码绘制球体。我希望能够可视化，以便在需要时可以修改球体。

Answer 1

一种方法是从具有三角形边的柏拉图立体开始 - 一个八面体，对于例子。然后，将每个三角形递归地分解为更小的三角形，如下所示：

一旦你有足够的数量对于点，您可以标准化它们的向量，以便它们与实体中心的距离都是恒定的。这会导致侧面凸出成类似球体的形状，随着点数的增加，平滑度也会增加。

这里的归一化意味着移动一个点，使其相对于另一个点的角度相同，但它们之间的距离不同。
这是一个二维的例子。

A 和 B 相距 6 个单位。但是假设我们想在 AB 线上找到一个距离 A 12 个单位的点。

我们可以这样说C 是 B 相对于 A 的归一化形式，距离为 12。我们可以通过如下代码获得 C：

#returns a point collinear to A and B, a given distance away from A. 
function normalize(a, b, length):
    #get the distance between a and b along the x and y axes
    dx = b.x - a.x
    dy = b.y - a.y
    #right now, sqrt(dx^2 + dy^2) = distance(a,b).
    #we want to modify them so that sqrt(dx^2 + dy^2) = the given length.
    dx = dx * length / distance(a,b)
    dy = dy * length / distance(a,b)
    point c =  new point
    c.x = a.x + dx
    c.y = a.y + dy
    return c

如果我们对很多点进行归一化处理，所有点都相对于同一点 A 并且具有相同的距离R，然后是归一化点都将位于以 A 为圆心、以 R 为半径的圆弧上。

这里，黑点开始于一条线并“凸出”成弧形。

这个过程可以扩展到三个维度，在这种情况下你会得到一个球体而不是一个圆。只需将 dz 分量添加到归一化函数即可。

如果您在 Epcot，您可以看到这种技术的工作原理。它是一个十二面体，表面凸出，使其看起来更圆。

Answer 2

我将进一步解释使用纬度和经度生成球体的流行方法（另一种
方式，icospheres，已经在撰写本文时最流行的答案中进行了解释。）

球体可以通过以下参数方程表示：

F( u, v) = [ cos(u)*sin(v)*r, cos(v)*r, sin(u)*sin(v)*r ]

其中：

• r 是半径；
• u是经度，范围是0到2π；
• v 是纬度，范围从 0 到 π。

然后生成球体涉及以固定时间间隔评估参数函数。

例如，要生成 16 条经度线，沿 u 轴将有 17 条网格线，步长为
π/8 (2π/16)（第 17 行环绕）。

以下伪代码通过评估参数函数来生成三角形网格
定期（这适用于任何参数表面函数，而不仅仅是球体）。

在下面的伪代码中，UResolution是沿 U 轴的网格点数
（此处为经度线），VResolution 是沿 V 轴的网格点数
（这里是纬线）

var startU=0
var startV=0
var endU=PI*2
var endV=PI
var stepU=(endU-startU)/UResolution // step size between U-points on the grid
var stepV=(endV-startV)/VResolution // step size between V-points on the grid
for(var i=0;i<UResolution;i++){ // U-points
 for(var j=0;j<VResolution;j++){ // V-points
 var u=i*stepU+startU
 var v=j*stepV+startV
 var un=(i+1==UResolution) ? endU : (i+1)*stepU+startU
 var vn=(j+1==VResolution) ? endV : (j+1)*stepV+startV
 // Find the four points of the grid
 // square by evaluating the parametric
 // surface function
 var p0=F(u, v)
 var p1=F(u, vn)
 var p2=F(un, v)
 var p3=F(un, vn)
 // NOTE: For spheres, the normal is just the normalized
 // version of each vertex point; this generally won't be the case for
 // other parametric surfaces.
 // Output the first triangle of this grid square
 triangle(p0, p2, p1)
 // Output the other triangle of this grid square
 triangle(p3, p1, p2)
 }
}

Answer 3

示例中的代码很快得到了解释。您应该查看函数 void drawSphere(double r, int lats, int longs)：

void drawSphere(double r, int lats, int longs) {
    int i, j;
    for(i = 0; i <= lats; i++) {
        double lat0 = M_PI * (-0.5 + (double) (i - 1) / lats);
        double z0  = sin(lat0);
        double zr0 =  cos(lat0);

        double lat1 = M_PI * (-0.5 + (double) i / lats);
        double z1 = sin(lat1);
        double zr1 = cos(lat1);

        glBegin(GL_QUAD_STRIP);
        for(j = 0; j <= longs; j++) {
            double lng = 2 * M_PI * (double) (j - 1) / longs;
            double x = cos(lng);
            double y = sin(lng);

            glNormal3f(x * zr0, y * zr0, z0);
            glVertex3f(r * x * zr0, r * y * zr0, r * z0);
            glNormal3f(x * zr1, y * zr1, z1);
            glVertex3f(r * x * zr1, r * y * zr1, r * z1);
        }
        glEnd();
    }
}

参数 lat 定义您想要在球体中拥有多少条水平线，< code>lon 有多少条垂直线。 r 是球体的半径。

现在，对lat/lon进行了两次迭代，并使用简单的三角函数计算顶点坐标。

计算出的顶点现在使用 glVertex...() 作为 GL_QUAD_STRIP 发送到您的 GPU，这意味着您发送的每两个顶点与之前的两个顶点形成一个四边形发送。

现在你需要了解的是三角函数是如何工作的，但我想你可以很容易地弄清楚。

Answer 4

如果你想像狐狸一样狡猾，你可以将 GLU 的代码修改半英寸。查看 MesaGL 源代码 (http://cgit.freedesktop.org/mesa/mesa/)。

Answer 5

请参阅OpenGL红皮书： http://www.glprogramming.com/red/chapter02.html #名称8
它通过多边形细分来解决问题。

Answer 6

我的示例如何使用“三角形带”绘制“极”球体，它包括成对绘制点：

const float PI = 3.141592f;
GLfloat x, y, z, alpha, beta; // Storage for coordinates and angles        
GLfloat radius = 60.0f;
int gradation = 20;

for (alpha = 0.0; alpha < GL_PI; alpha += PI/gradation)
{        
    glBegin(GL_TRIANGLE_STRIP);
    for (beta = 0.0; beta < 2.01*GL_PI; beta += PI/gradation)            
    {            
        x = radius*cos(beta)*sin(alpha);
        y = radius*sin(beta)*sin(alpha);
        z = radius*cos(alpha);
        glVertex3f(x, y, z);
        x = radius*cos(beta)*sin(alpha + PI/gradation);
        y = radius*sin(beta)*sin(alpha + PI/gradation);
        z = radius*cos(alpha + PI/gradation);            
        glVertex3f(x, y, z);            
    }        
    glEnd();
}

输入的第一个点（glVertex3f）如下参数方程，第二个点移动一个 alpha 角度（从下一条平行线开始）。

Answer 7

尽管接受的答案解决了问题，但最后还是存在一些误解。 十二面体是（或可能是）正多面体，其中所有面都具有相同的面积。 Epcot 似乎就是这种情况（顺便说一下，它根本不是十二面体）。由于@Kevin 提出的解决方案没有提供此特征，我认为我可以添加一种可以提供此特征的方法。

生成 N 面多面体（其中所有顶点都位于同一个球体中且其所有面具有相似面积/表面的好方法）是从二十面体开始，并迭代细分和标准化其三角形面（如已接受的答案中所建议的）。例如，十二面体实际上是截断二十面体。

正二十面体有 20 个面（12 个顶点），可以轻松地由 3 个黄金矩形构建而成；问题只是以此为起点而不是八面体。您可以在此处找到示例。

我知道这有点偏离主题，但我相信如果有人来这里寻找这个具体案例，这可能会有所帮助。

Answer 8

@Constantinius 答案的 Python 改编：

lats = 10
longs = 10
r = 10

for i in range(lats):
    lat0 = pi * (-0.5 + i / lats)
    z0 = sin(lat0)
    zr0 = cos(lat0)

    lat1 = pi * (-0.5 + (i+1) / lats)
    z1 = sin(lat1)
    zr1 = cos(lat1)

    glBegin(GL_QUAD_STRIP)
    for j in range(longs+1):
        lng = 2 * pi * (j+1) / longs
        x = cos(lng)
        y = sin(lng)

        glNormal(x * zr0, y * zr0, z0)
        glVertex(r * x * zr0, r * y * zr0, r * z0)
        glNormal(x * zr1, y * zr1, z1)
        glVertex(r * x * zr1, r * y * zr1, r * z1)

    glEnd()

Answer 9

   void draw_sphere(float r)
    {
    
        float pi = 3.141592;
        float di = 0.02;
        float dj = 0.04;
        float db = di * 2 * pi;
        float da = dj * pi;
    
    
        for (float i = 0; i < 1.0; i += di) //horizonal
            for (float j = 0; j < 1.0; j += dj) //vertical
            {
                float b = i * 2 * pi;      //0     to  2pi
                float a = (j - 0.5) * pi;  //-pi/2 to pi/2
    
    
                //normal
                glNormal3f(
                    cos(a + da / 2) * cos(b + db / 2),
                    cos(a + da / 2) * sin(b + db / 2),
                    sin(a + da / 2));
    
                glBegin(GL_QUADS);
                //P1
                    glTexCoord2f(i, j);
                    glVertex3f(
                        r * cos(a) * cos(b),
                        r * cos(a) * sin(b),
                        r * sin(a));
                //P2
                    glTexCoord2f(i + di, j);//P2
                    glVertex3f(
                        r * cos(a) * cos(b + db),
                        r * cos(a) * sin(b + db),
                        r * sin(a));
                //P3
                    glTexCoord2f(i + di, j + dj);
                    glVertex3f(
                        r * cos(a + da) * cos(b + db),
                        r * cos(a + da) * sin(b + db),
                        r * sin(a + da));
                //P4
                    glTexCoord2f(i, j + dj);
                    glVertex3f(
                        r * cos(a + da) * cos(b),
                        r * cos(a + da) * sin(b),
                        r * sin(a + da));
                glEnd();
            }
    }

Answer 10

一种方法是制作一个面向相机的四边形，并编写一个顶点和片段着色器来渲染看起来像球体的东西。您可以使用在互联网上找到的圆/球体方程。

一件好事是球体的轮廓从任何角度看起来都是一样的。然而，如果球体不在透视图的中心，那么它看起来可能更像一个椭圆形。您可以计算出这个方程并将它们放入片段阴影中。如果您确实有一个玩家在球体周围的 3D 空间中移动，那么光线着色需要随着玩家的移动而改变。

任何人都可以评论一下他们是否尝试过这个或者它是否太昂贵而不实用？