final.cpp

#include <GL/glut.h>
#include <GL/glaux.h>
#include <math.h>
#include <string>
#include <mmsystem.h>
#include <iostream>
#include "hd.h"
#include <vector>
#ifndef GL_POINT_SPRITE
#define GL_POINT_SPRITE 0x8861
#endif
#include <set>
#include <random>

using namespace std;

#define Faster 1
#define Slower 2
#define Switch_view 3
#define Orbit_view 4

GLfloat PI = acos(-1.0);
GLUquadricObj* qobj;
GLubyte* pImg;
GLint iWidth, iHeight;
GLfloat fps = 90;
//string str = "nmp4";
//str.c_str();
string Texture_Path[12] = {
    "texture_sun_8K.bmp",
    "texture_Mercury_8K.bmp",
    "texture_Venus_8K.bmp",
    "texture_earth_2K.bmp",
    "texture_Mars_8K.bmp",
    "texture_Jupiter_8K.bmp",
    "texture_Saturn_8K.bmp",
    "texture_Uranus_2K.bmp",
    "texture_Neptune_2K.bmp",
    "texture_moon_2K.bmp",
    "texture_back_2K.bmp",
    "texture_huan_2K.bmp"
};
string skyTexture_Path[6] = {
    "right.bmp",
    "left.bmp",
    "top.bmp",
    "bottom.bmp",
    "front.bmp",
    "back.bmp"
};
GLuint texName[12];
GLuint skyboxTextures[6];
AUX_RGBImageRec* TextureImage[12];
AUX_RGBImageRec* skyTextureImage[12];
GLfloat view_type = 1; // 视图类型 1--模拟， 2--拟真
GLfloat view_orbit = 1; // 轨道显示
GLfloat base_r = 3; // 基准轨道半径
GLfloat base = 0.1; // 基准半径
GLfloat base_gz = 2 * PI / (fps * 20); // 地球公转一圈的时间为30s
GLfloat base_zz = 360.0 / fps / 5; // 地球自转一圈的时间为5s
const float piover180 = 0.0174532925f;//折算度和弧度的折算因子3.1415926/180
float angle = 0.0;//angle绕y轴的旋转角
// 视角相关变量
GLdouble eyeX = -5, eyeY = 5, eyeZ = 6;
GLdouble centerX = 0.0, centerY = 0.0, centerZ = 0.0;
GLdouble upX = 0.0, upY = 0.0, upZ = 1.0;

// 移动速度
GLfloat moveSpeed = 0.05;
GLfloat rotateSpeed = 3.0;
int     LastXPos, LastYPos, LastZPos;   //上次鼠标点击处x、y坐标
BOOL    IsLBDown = FALSE;    //鼠标左键是否按下
GLfloat xrot;    // 绕X轴旋转的角度
GLfloat yrot;    // 绕Y轴旋转的角度
GLfloat zrot;    // 绕Z轴旋转的角度
float heading;                        //头向左右偏转的角度
//此处定义镜头在xoz平面上移动的x坐标和z坐标
float xpos;
float zpos;

int currentFollowIndex = -1;
int position[3] = { -5,5,4 };
int position2[3] = { -5,5,3 };
GLfloat LastX, LastY;

GLfloat	Yrot;				// Y 旋转角度
//GLfloat walkbias = 0;        //当人行走时头部产生上下摆动的幅度。我们使用简单的sine正弦波来调节镜头的Y轴位置。
//GLfloat walkbiasangle = 0;
GLfloat lookupdown = 0.0f, lookleftright = 0.0f;    //定义上下看的旋转角度
GLfloat	z = 0.0f;				// Depth Into The Screen
int flag = 1;

// 天体结构
struct Body {
    GLfloat x, y, z; // 位置
    GLfloat cx, cy, cz; // 摄像机位置
    GLfloat dx, dy, dz; // 速度
    GLfloat orbitRadius; // 轨道半径
    GLfloat radius; // 半径
    GLfloat angle; // 角度，用于计算位置
    GLfloat angularVelocity; // 角速度
    GLfloat r, g, b; // 颜色
    int number; // 序号
    GLfloat rotation; // 自转开始角度
    GLfloat dr; // 自转速度
    GLfloat bias; // 相机偏移量
    GLfloat tilt; // 偏移角
};
struct vec3 {
    float x, y, z;

    vec3(float x, float y, float z) : x(x), y(y), z(z) {}
};
struct bs
{
    GLfloat x, y, z; // 位置
};
// 小行星组
const int xxx_number = 3000;
Body xxxs[xxx_number] = {};
// 背景星星
const int bs_number = 6000;
Body backstar[bs_number] = {};
// 天体列表
Body sun = {
    0, 0, 0,
    0, 0, 0,
    0, 0, 0,
    0,
    1, // 天体半径，地球在屏幕上的大小
    0.0, // 初始角度
    0.01, // 角速度
    1,1,1,0,//rgb，name
    0,base_zz / 25.4, //roation
    0,
    0
}; // 太阳在原点
Body Mercury = {
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0,
    0, 0, 0, // 初始速度为0
    base_r * 0.3871, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 0.382, // 天体半径，地球在屏幕上的大小
    0.0, // 初始角度
    base_gz * 365 / 88, // 角速度
    1,1,1,1,
    0,base_zz / 59,
    28,
    0
};
Body Venus = {
    0, 0, 0,
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0, // 初始速度为0
    base_r * 0.7233, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 0.949 , // 天体半径，地球在屏幕上的大小
    0.0, // 初始角度
    base_gz * 365 / 224, // 角速度
    1,1,1,2,
    0,base_zz / (-243),
    12,
    177
};
Body moon = {
    0, 0, 0,
    0, 0, 0,
    0, 0, 0,
    base * 1.5, // 轨道半径，
    base * 0.273, // 天体半径，地球在屏幕上的大小
    0.0, // 初始角度
    base_gz * 365 / 27, // 角速度
    1,1,1,9,
    0,base_zz / 27,
    40,
    0
}; // 月亮
Body earth = {
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0,
    0, 0, 0, // 初始速度为0
    base_r * 1, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base, // 天体半径，地球在屏幕上的大小
    0.0, // 初始角度
    base_gz, // 角速度
    1,1,1,3,
    0,base_zz,
    12,
    23
};
Body Mars = {
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0,
    0, 0, 0, // 初始速度为0
    base_r * 1.5237, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 0.532, // 天体半径，地球在屏幕上的大小
    0.0, // 初始角度
    base_gz * 365 / 687, // 角速度
    1,1,1,4,
    0,base_zz,
    21,
    25
};
Body Jupiter = {
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0,
    0, 0, 0, // 初始速度为0
    base_r * 5.2026, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 11.209, // 天体半径，地球在屏幕上的大小
    radians(0), // 初始角度
    base_gz / 11.86, // 角速度
    1,1,1,5,
    0,base_zz * 24 / 10,
    3,
    3
};
Body Saturn = {
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0,
    0, 0, 0, // 初始速度为0
    base_r * 9.5549, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 9.449, // 天体半径，地球在屏幕上的大小
    radians(-30), // 初始角度
    base_gz / 29.5, // 角速度
    1,1,1,6,
    0,base_zz * 24 / 10.5,
    5,
    30
};
Body Uranus = {
    0, 0, 0,
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0, // 初始速度为0
    base_r * 19.2184, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 4.007, // 天体半径，地球在屏幕上的大小
    radians(-60), // 初始角度
    base_gz / 84, // 角速度
    1,1,1,7,
    0,base_zz * 24 / 17,
    7,
    98
};
Body Neptune = {
    0, 0, 0,
    0, 0, 0, // 初始位置在太阳旁边
    0, 0, 0, // 初始速度为0
    base_r * 30.1104, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 3.883, // 天体半径，地球在屏幕上的大小
    radians(-90), // 初始角度
    base_gz / 164.82, // 角速度
    1,1,1,8,
    0,base_zz * 24 / 16,
    7,
    30
};
Body hx = {
    0, 0, 0,
    0, 0, 0, // 初始位置在太阳旁边
    2, 2, 0, // 初始速度为0
    base_r * 1.5, // 轨道半径，可以是任意单位，这里用1.0表示简化计算
    base * 0.3, // 天体半径，地球在屏幕上的大小
    radians(0), // 初始角度
    base_gz / 2.82, // 角速度
    1,1,1,-1,
    0,base_zz * 24 / 16,
    10,
    30
};



Body planet[11] = { sun, Mercury, Venus, earth, Mars, Jupiter, Saturn, Uranus, Neptune, moon, hx };
Body save[11] = { sun, Mercury, Venus, earth, Mars, Jupiter, Saturn, Uranus, Neptune, moon, hx };


// 粒子类
class Particle {
public:
    float x, y, z; // 位置
    float vx, vy, vz; // 速度
    float life; // 生命周期
    float size; // 大小
    vec3 color; // 颜色

    Particle(float x, float y, float z, float vx, float vy, float vz, float life, float size, vec3 color)
        : x(x), y(y), z(z), vx(vx), vy(vy), vz(vz), life(life), size(size), color(color) {}

    Particle(vec3 xyz, float life, float size, vec3 color)
        : x(xyz.x), y(xyz.y), z(xyz.z), life(life), size(size), color(color) {}

    void update() {
        // 更新位置
        x += vx;
        y += vy;
        z += vz;

        // 更新生命周期-
        life -= 0.01;

        // 可以添加更多的物理效果，如重力、空气阻力等
    }

    bool isDead() {
        return life <= 0;
    }
};

double dist(double x, double y, double z, double a, double b, double c)
{
    return sqrt((x - a) * (x - a) + (y - b) * (y - b) + (z - c) * (z - c));
}
// 设置随机数种子
void setRandomSeed() {
    std::srand(static_cast<unsigned int>(std::time(nullptr)));
}

// 生成范围内的随机浮点数
float randomFloat(float min, float max) {
    return min + static_cast<float>(std::rand()) / (static_cast<float>(RAND_MAX / (max - min)));
}

// 粒子发射器类
class ParticleEmitter {
private:
    std::vector<Particle> particles;

public:
    void updateParticleSize(Particle particle) {
        // 根据距离调整大小
        float distance = sqrt(particle.x * particle.x + particle.y * particle.y + particle.z * particle.z);
        float size = 10.0f / distance; // 反比于距离
        glPointSize(size);
    }
    void updatelife(Body particle,double &li)
    {
        float distance = sqrt(particle.x * particle.x + particle.y * particle.y + particle.z * particle.z);
        li = 0.5f / distance; // 反比于距离
    }
    void emitParticle(float x, float y, float z) {
        // 创建一个新的粒子
        double len = dist(planet[10].x, planet[10].y, planet[10].z, 0, 0, 0) * 60;
        double li;
        updatelife(planet[10], li);
        Particle p(x, y, z, planet[10].x / len, planet[10].y / len, planet[10].z / len , li, 10.0, vec3(1.0, 1.0, 1.0)); // 流星颜色偏黄
        //Particle p(x, y, z, tangentX, tangentY, tangentY, 0.5, 10.0, vec3(1.0, 1.0, 1.0)); // 流星颜色偏黄
        particles.push_back(p);
    }

    void update() {
        // 更新所有粒子
        for (auto it = particles.begin(); it != particles.end(); ) {
            it->update();
            if (it->isDead()) {
                it = particles.erase(it);
            }
            else {
                ++it;
            }
        }
    }

    void render() {
        // 启用点精灵
        glPushMatrix();
        glEnable(GL_POINT_SPRITE);
        

        // 渲染所有粒子
        for (const auto& p : particles) {
            GLfloat tempColor[3] = { p.color.x, p.color.y, p.color.z };
            // 设置点的大小
            updateParticleSize(p);
            glBegin(GL_POINTS);
            glColor3fv(tempColor);
            //if (p.color.y == 0.9) 
            glVertex3f(p.x, p.y, p.z);
            glEnd();
        }
        // 禁用点精灵
        glDisable(GL_POINT_SPRITE);
        //glEnable(GL_DEPTH_TEST);
        glPopMatrix();
    }
};

// 全局粒子发射器
ParticleEmitter emitter;


// 随机生成半径为r的球体上的坐标
vec3 randomPointOnSphere(float r) {
    // 随机生成极角 theta 和方位角 phi
    float theta = randomFloat(0.0f, (float)PI); // theta 在 [0, π] 范围内
    float phi = randomFloat(0.0f, 2.0f * (float)PI); // phi 在 [0, 2π] 范围内

    // 使用球坐标转换为笛卡尔坐标
    float x = r * sin(theta) * cos(phi);
    float y = r * sin(theta) * sin(phi);
    float z = r * cos(theta);

    return vec3(x, y, z);
}

// 更新天体位置
void updatePositions(int value) {
    for (int i = 0; i < 11; i++)
    {
        int fh;
        if (view_type == 1) fh = -1;
        else fh = 1;
        if (i == 9) // 更新月球的轨道数据
        {
            planet[i].rotation += planet[i].dr;
            // 更新月球的角度
            planet[i].angle += planet[i].angularVelocity;
            planet[i].x = planet[3].x + planet[i].orbitRadius * cos(planet[i].angle);
            planet[i].y = planet[3].y + planet[i].orbitRadius * sin(planet[i].angle);
            //[i].z = 0;
            planet[i].cx = planet[3].x + (planet[i].orbitRadius + fh * planet[i].radius * planet[i].bias) * cos(planet[i].angle);
            planet[i].cy = planet[3].y + (planet[i].orbitRadius + fh * planet[i].radius * planet[i].bias) * sin(planet[i].angle);
            planet[i].cz = planet[i].radius; // 假设在二维平面上运动
        }
        else
        {
            planet[i].rotation += planet[i].dr;
            // 更新地球的角度
            planet[i].angle += planet[i].angularVelocity;
            // 使用三角函数计算新的位置
            planet[i].x = planet[i].orbitRadius * cos(planet[i].angle);
            planet[i].y = planet[i].orbitRadius * sin(planet[i].angle);
            planet[i].x += planet[i].dx;
            planet[i].y += planet[i].dy;
            //planet[i].z = 0; // 假设在二维平面上运动
            planet[i].cx = (planet[i].orbitRadius + fh * planet[i].radius * planet[i].bias) * cos(planet[i].angle + planet[i].angularVelocity * 10);
            planet[i].cy = (planet[i].orbitRadius + fh * planet[i].radius * planet[i].bias) * sin(planet[i].angle + planet[i].angularVelocity * 10);
            planet[i].cz = planet[i].radius * 0; // 假设在二维平面上运动
        }
    }
    for (int i = 0; i < xxx_number; i++)
    {
        xxxs[i].rotation += xxxs[i].dr;
        xxxs[i].angle += xxxs[i].angularVelocity;
        // 使用三角函数计算新的位置
        xxxs[i].x = xxxs[i].orbitRadius * cos(xxxs[i].angle);
        xxxs[i].y = xxxs[i].orbitRadius * sin(xxxs[i].angle);
    }
    emitter.emitParticle(planet[10].x, planet[10].y, planet[10].z); // 在原点发射一个粒子

    glutPostRedisplay(); // 标记窗口需要重绘
    glutTimerFunc(1000 / fps, updatePositions, 0); // 重新设置定时器
}

// 绘制轨道
void DrawCircle(GLdouble x, GLdouble y, GLdouble R, int number) {
    glPushMatrix();
    //glRotatef(90.0, 1.0, 0.0, 0.0);
    if (number == -1) glColor4f(0.5, 0.5, 0.5, 1.0);
    else glColor4f(1.0, 1.0, 1.0, 1.0);
    glBegin(GL_LINE_LOOP);
    for (int i = 0; i < 1000; i++) {
        GLdouble angle1 = i * 2 * 3.14 / 1000;
        glVertex3d(x + R * cos(angle1), y + R * sin(angle1), 0);
    }
    glEnd();
    glPopMatrix();
}

// 绘制天体
void drawBody(Body body) {
    glPushMatrix();
    qobj = gluNewQuadric();
    glEnable(GL_TEXTURE_2D);
    glTranslatef(body.x, body.y, body.z);
    glRotatef(body.tilt, 1.0, 0.0, 0.0);
    glRotatef(body.rotation, 0.0, 0.0, 1.0);
    if (body.number != -1)
    {
        glBindTexture(GL_TEXTURE_2D, texName[body.number]);
        gluQuadricTexture(qobj, GL_TRUE);//纹理函数
    }
    glColor3f(body.r, body.g, body.b);
    gluSphere(qobj, body.radius, 60, 60);//二次曲面qobj
    glDisable(GL_TEXTURE_2D);
    glPopMatrix();
}
// 绘制坐标系
void draw_xyz()
{
    glPushMatrix();
    glBegin(GL_LINES);
    glColor3f(1.0, 0.0, 0.0);
    glVertex3d(0, 0, 0);
    glVertex3d(10, 0, 0);
    glColor3f(0.0, 1.0, 0.0);
    glVertex3d(0, 0, 0);
    glVertex3d(0, 10, 0);
    glColor3f(0.0, 0.0, 1.0);
    glVertex3d(0, 0, 0);
    glVertex3d(0, 0, 10);
    glEnd();
    glPopMatrix();
}

GLfloat radians(GLfloat x)
{
    return x * PI / 180.0;
}

// 渲染光环
void renderTorus() {

    GLUquadric* huan = gluNewQuadric();
    glPushMatrix();


    glEnable(GL_TEXTURE_2D);
    glColor3f(1, 1, 1);
    glBindTexture(GL_TEXTURE_2D, texName[11]);

    gluQuadricTexture(huan, GL_TRUE); // 启用纹理
    gluQuadricNormals(huan, GLU_SMOOTH); // 设置法线

    glTranslatef(planet[6].x, planet[6].y, planet[6].z); // 根据需要调整光环的位置
    glRotated(planet[6].angularVelocity, 0, 0, 1);
    glRotatef(planet[6].tilt, 1.0, 0.0, 0.0);

    gluDisk(huan, planet[6].radius * 1.3, planet[6].radius * 2.2, 50, 50); // 内半径为1.0，外半径为1.1，环宽0.1
    glDisable(GL_TEXTURE_2D);

    //glEnd();
    glPopMatrix();

    glPushMatrix();
    huan = gluNewQuadric();

    glTranslatef(planet[7].x, planet[7].y, planet[7].z); // 根据需要调整光环的位置
    glRotated(planet[7].angularVelocity, 0, 0, 1);
    glRotatef(planet[7].tilt, 1.0, 0.0, 0.0);
    glColor3f(1, 1, 1);
    gluDisk(huan, planet[7].radius * 1.3, planet[7].radius * 1.35, 50, 50); // 内半径为1.0，外半径为1.1，环宽0.1
    glPopMatrix();
}

// 绘制天空盒的函数
void renderSkybox() {
    glDisable(GL_DEPTH_TEST); // 禁用深度测试，防止天空盒被深度缓冲影响
    glEnable(GL_TEXTURE_2D);
    glPushMatrix(); // 保存当前的模型视图矩阵

    // 绑定纹理并渲染立方体的每个面
    glBindTexture(GL_TEXTURE_2D, skyboxTextures[0]); // 右面
    glBegin(GL_QUADS);
    glTexCoord2f(1.0, 0.0); glVertex3f(100.0, -100.0, -100.0);
    glTexCoord2f(0.0, 0.0); glVertex3f(100.0, 100.0, -100.0);
    glTexCoord2f(0.0, 1.0); glVertex3f(100.0, 100.0, 100.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(100.0, -100.0, 100.0);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, skyboxTextures[1]); // 左面
    glBegin(GL_QUADS);
    glTexCoord2f(1.0, 0.0); glVertex3f(-100.0, -100.0, -100.0);
    glTexCoord2f(0.0, 0.0); glVertex3f(-100.0, 100.0, -100.0);
    glTexCoord2f(0.0, 1.0); glVertex3f(-100.0, 100.0, 100.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(-100.0, -100.0, 100.0);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, skyboxTextures[2]); // 顶面
    glBegin(GL_QUADS);
    glTexCoord2f(0.0, 0.0); glVertex3f(-100.0, 100.0, -100.0);
    glTexCoord2f(1.0, 0.0); glVertex3f(100.0, 100.0, -100.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(100.0, 100.0, 100.0);
    glTexCoord2f(0.0, 1.0); glVertex3f(-100.0, 100.0, 100.0);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, skyboxTextures[3]); // 底面
    glBegin(GL_QUADS);
    glTexCoord2f(1.0, 0.0); glVertex3f(-100.0, -100.0, -100.0);
    glTexCoord2f(0.0, 0.0); glVertex3f(100.0, -100.0, -100.0);
    glTexCoord2f(0.0, 1.0); glVertex3f(100.0, -100.0, 100.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(-100.0, -100.0, 100.0);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, skyboxTextures[4]); // 前面
    glBegin(GL_QUADS);
    glTexCoord2f(0.0, 0.0); glVertex3f(-100.0, -100.0, 100.0);
    glTexCoord2f(1.0, 0.0); glVertex3f(100.0, -100.0, 100.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(100.0, 100.0, 100.0);
    glTexCoord2f(0.0, 1.0); glVertex3f(-100.0, 100.0, 100.0);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, skyboxTextures[5]); // 后面
    glBegin(GL_QUADS);
    glTexCoord2f(1.0, 0.0); glVertex3f(-100.0, -100.0, -100.0);
    glTexCoord2f(0.0, 0.0); glVertex3f(100.0, -100.0, -100.0);
    glTexCoord2f(0.0, 1.0); glVertex3f(100.0, 100.0, -100.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(-100.0, 100.0, -100.0);
    glEnd();

    glPopMatrix(); // 恢复之前的模型视图矩阵
    glDisable(GL_TEXTURE_2D);
    glEnable(GL_DEPTH_TEST); // 启用深度测试
}

//音乐
void music()
{
    MCI_OPEN_PARMS op;                                     //播放背景音乐
    op.dwCallback = NULL;
    op.lpstrAlias = NULL;
    op.lpstrDeviceType = "MPEGAudio";
    op.lpstrElementName = "A Moment Apart-ODESZA#htUPm(1).mp3";
    op.wDeviceID = NULL;
    UINT rs;
    rs = mciSendCommand(NULL, MCI_OPEN, MCI_OPEN_ELEMENT, (DWORD)&op);
    if (rs == 0)
    {
        MCI_PLAY_PARMS pp;
        pp.dwCallback = NULL;
        pp.dwFrom = 0;
        mciSendCommand(op.wDeviceID, MCI_PLAY, MCI_NOTIFY, (DWORD)&pp);
    }
}

// OpenGL渲染回调函数
void display() {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // 绘制椭圆轨道
    //drawEllipse(a, b);
    if (view_type == 1)
    {
        renderSkybox(); // 渲染背景
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        GLfloat xtrans = -xpos;               // 用于游戏者沿X轴平移时的大小
        GLfloat ztrans = -zpos;               // 用于游戏者沿Z轴平移时的大小
        GLfloat sceneroty = 360.0 - Yrot;   // 使得左右键与旋转方向一致

        glRotatef(lookupdown, 1.0f, 0.0f, 0.0f);       //相应PageUp、PageDown进行向上/向下看的旋转,沿x轴旋转
        glRotatef(lookleftright, 0.0f, 1.0f, 0.0f);       //相应PageUp、PageDown进行向上/向下看的旋转,沿x轴旋转
        glRotatef(sceneroty, 0.0f, 1.0f, 0.0f);        // 根据游戏者正面所对方向所作的左右旋转

        glTranslatef(xtrans, 0, ztrans);       //以游戏者为中心的平移场景

        gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);

        if (currentFollowIndex >= 0) updateCamera();

        glRotatef(xrot, 1.0f, 0.0f, 0.0f);    //沿x轴旋转
        glRotatef(yrot, 0.0f, 1.0f, 0.0f);    //沿y轴旋转

        light_sun();
        light_center();

        int base = 5;
        for (int i = 1; i < 11; i++)
        {
            planet[i].orbitRadius = base * (0.2 + i * 0.2);
        }
        planet[0].radius = base * 0.2;    planet[0].bias;
        planet[1].radius = base * 0.05;   planet[1].bias = 5;
        planet[2].radius = base * 0.05;   planet[2].bias = 5;
        planet[3].radius = base * 0.06;   planet[3].bias = 4.4;
        planet[4].radius = base * 0.06;   planet[4].bias = 4.45;
        planet[5].radius = base * 0.15;   planet[5].bias = 2.35;
        planet[6].radius = base * 0.1;    planet[6].bias = 4.25;
        planet[7].radius = base * 0.08;   planet[7].bias = 4.1;
        planet[8].radius = base * 0.07;   planet[8].bias = 3.9;
        planet[9].radius = base * 0.02;   planet[9].bias = 11.5;
        planet[9].orbitRadius = 0.5;
        planet[10].orbitRadius = 4.5;

        for (int i = 0; i < 11; i++)
        {
            if (i != 9 && view_orbit == 1) DrawCircle(planet[i].dx, planet[i].dy, planet[i].orbitRadius, planet[i].number);
            glColor3f(1.0, 1.0, 1.0);
            glPushMatrix();
            //glRotatef(planet[i].tilt, 1.0, 0.0, 0.0);
            drawBody(planet[i]);
            glPopMatrix();
        }
        renderTorus();
        // 更新和渲染粒子
        emitter.update();
        emitter.render();
    }
    else
    {
        renderSkybox(); // 渲染背景
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        GLfloat xtrans = -xpos;               // 用于游戏者沿X轴平移时的大小
        GLfloat ztrans = -zpos;               // 用于游戏者沿Z轴平移时的大小
        GLfloat sceneroty = 360.0 - Yrot;   // 使得左右键与旋转方向一致
        glRotatef(lookupdown, 1.0f, 0.0f, 0.0f);       //相应PageUp、PageDown进行向上/向下看的旋转,沿x轴旋转
        glRotatef(lookleftright, 0.0f, 1.0f, 0.0f);       //相应PageUp、PageDown进行向上/向下看的旋转,沿x轴旋转
        glRotatef(sceneroty, 0.0f, 1.0f, 0.0f);        // 根据游戏者正面所对方向所作的左右旋转

        glTranslatef(xtrans, 0, ztrans);       //以游戏者为中心的平移场景

        gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);

        if (currentFollowIndex >= 0) updateCamera();


        glRotatef(xrot, 1.0f, 0.0f, 0.0f);    //沿x轴旋转
        glRotatef(yrot, 0.0f, 1.0f, 0.0f);    //沿y轴旋转

        light_sun();
        light_center();
        //draw_xyz();

        for (int i = 0; i < 11; i++)
        {
            if (i != 9 && view_orbit == 1) DrawCircle(planet[i].dx, planet[i].dy, planet[i].orbitRadius,planet[i].number);
            glColor3f(1.0, 1.0, 1.0);
            glPushMatrix();
            drawBody(planet[i]);
            glPopMatrix();
        }
        Drawxxx();

        renderTorus();
        // 更新和渲染粒子
        emitter.update();
        emitter.render();

        //glEnable(GL_DEPTH_TEST);
    }
    Drawbackground();

    glutSwapBuffers();
}

// 窗口大小改变时的回调函数
void reshape(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, (GLfloat)w / (GLfloat)h, 1.0, 1000.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

// 切换视图是初始化天体的属性和摄像机位置
void changeview()
{
    for (int i = 0; i < 11; i++) planet[i] = save[i];
    if (view_type == 2)
    {
        eyeX = position2[0], eyeY = position2[1], eyeZ = position2[1];
        centerX = 0.0, centerY = 0.0, centerZ = 0.0;
        upX = 0.0, upY = 0.0, upZ = 1.0;
        xrot = 15;
    }
    else
    {
        eyeX = position[0], eyeY = position[1], eyeZ = position[2];
        centerX = 0.0, centerY = 0.0, centerZ = 0.0;
        upX = 0.0, upY = 0.0, upZ = 1.0;
    }
}
//选择菜单项处理
void processMenuEvents(int option)
{
    //option，就是传递过来的value的值。         
    switch (option) {
    case Faster:
        for (int i = 0; i < 11; i++)
        {
            planet[i].angularVelocity *= 2;
            planet[i].dr *= 2;
        }
        break;
    case Slower:
        for (int i = 0; i < 11; i++)
        {
            planet[i].angularVelocity /= 2;
            planet[i].dr /= 2;
        }
        break;
    case Switch_view:
        view_type = 3 - view_type;
        changeview();
        break;
    case Orbit_view:
        view_orbit = 1 - view_orbit;
        break;
    }
}
//创建菜单
void createGLUTMenus()
{
    int menu;
    // 创建菜单并告诉GLUT，processMenuEvents处理菜单事件。         
    menu = glutCreateMenu(processMenuEvents);
    //给菜单增加条目         
    glutAddMenuEntry("Speed Up", Faster);
    glutAddMenuEntry("Speed Down", Slower);
    glutAddMenuEntry("Switch_View", Switch_view);
    glutAddMenuEntry("Orbit_View", Orbit_view);
    // 把菜单和鼠标右键关联起来。        
    glutAttachMenu(GLUT_RIGHT_BUTTON);
}



//对特殊键盘的交互响应处理
void specialKey(int key, int x, int y)
{
    switch (key)
    {
    case GLUT_KEY_PAGE_UP:      //按下PageUp，向上看
        z -= 0.02f;
        lookupdown -= 1.0f;
        break;
    case GLUT_KEY_PAGE_DOWN:        //按下PageDown，向下看
        z += 0.02f;
        lookupdown += 1.0f;
        break;
    case GLUT_KEY_END:
        lookleftright -= 1.0f;
        break;
    case GLUT_KEY_HOME:
        lookleftright += 1.0f;
        break;
    case GLUT_KEY_UP:
        //计算镜头在x和z轴方向上的移动量，heading为头的偏移方向与z轴夹角
        xpos -= (float)sin(heading * piover180) * 0.05f;// 沿游戏者所在的X平面移动
        zpos -= (float)cos(heading * piover180) * 0.05f;// 沿游戏者所在的Z平面移动
        break;
    case GLUT_KEY_DOWN:
        xpos += (float)sin(heading * piover180) * 0.05f;// 沿游戏者所在的X平面移动
        zpos += (float)cos(heading * piover180) * 0.05f;// 沿游戏者所在的Z平面移动
        break;
    case GLUT_KEY_LEFT:
        heading += 1.0f;
        Yrot = heading;         // 向右侧旋转场景
        break;
    case GLUT_KEY_RIGHT:
        heading -= 1.0f;
        Yrot = heading;         // 向左旋转场景
        break;
    }
}


// 根据当前跟随天体更新相机位置和目标点
void updateCamera() {
    if (currentFollowIndex > 0) {
        eyeX = planet[currentFollowIndex].cx;
        eyeY = planet[currentFollowIndex].cy;
        eyeZ = planet[currentFollowIndex].cz;
        if (currentFollowIndex == 9) {
            centerX = planet[3].x;
            centerY = planet[3].y;
            centerZ = planet[3].z;
        }
        else if (view_type == 1)
        {
            centerX = planet[currentFollowIndex].x;
            centerY = planet[currentFollowIndex].y;
            centerZ = planet[currentFollowIndex].z;
        }
        // 简单设置相机位置在天体后方一定距离，可根据需求调整
    }
    else
    {
        if (view_type == 2)
        {
            eyeX = position2[0], eyeY = position2[1], eyeZ = position2[1];
            centerX = 0.0, centerY = 0.0, centerZ = 0.0;
            upX = 0.0, upY = 0.0, upZ = 1.0;
        }
        else
        {
            eyeX = position[0], eyeY = position[1], eyeZ = position[1];
            centerX = 0.0, centerY = 0.0, centerZ = 0.0;
            upX = 0.0, upY = 0.0, upZ = 1.0;
        }
    }
}
void keyboard(unsigned char value, int x, int y)
{
    switch (value) {
    case '0': {
        currentFollowIndex = 0;  // 默认视角
        view_orbit = 0;
        break;
    }
    case '1': {
        currentFollowIndex = 1;  // 跟随水星
        view_orbit = 0;
        xrot = 0;
        break;
    }
    case '2': {
        currentFollowIndex = 2;  // 跟随
        view_orbit = 0;
        break;
    }
    case '3': {
        currentFollowIndex = 3;  // 跟随
        view_orbit = 0;
        break;
    }
    case '4': {
        currentFollowIndex = 4;  // 跟随
        view_orbit = 0;
        break;
    }
    case '5': {
        currentFollowIndex = 5;  // 跟随
        view_orbit = 0;
        break;
    }
    case '6': {
        currentFollowIndex = 6;  // 跟随
        view_orbit = 0;
        break;
    }
    case '7': {
        currentFollowIndex = 7;  // 跟随
        view_orbit = 0;
        break;
    }
    case '8': {
        currentFollowIndex = 8;  // 跟随
        view_orbit = 0;
        break;
    }
    case '9': {
        currentFollowIndex = 9;  // 跟随
        view_orbit = 0;
        break;
    }
    case ' ': {
        xrot = yrot = 0;
        xpos = zpos = 0;
        lookupdown = lookleftright = heading = Yrot = 0;
        if (view_type == 2) xrot = 15;
        break;
    }
    case 'h': {
        view_orbit = 1 - view_orbit;
        break;
    }
    case '+': {
        for (int i = 0; i < 11; i++)
        {
            planet[i].angularVelocity *= 2;
            planet[i].dr *= 2;
        }
        break;
    }
    case '-': {
        for (int i = 0; i < 11; i++)
        {
            planet[i].angularVelocity /= 2;
            planet[i].dr /= 2;
        }
        break;
    }
    case '\t':
    {
        view_type = 3 - view_type;
        changeview();
        break;
    }
    glutPostRedisplay();
    }
}
void light_sun() {

    GLfloat light_position0[] = { 0.0, 0.0, 0.0, 1.0 };   // 光源位置
    glLightfv(GL_LIGHT0, GL_POSITION, light_position0);     // 创建光源

    //太阳光
    GLfloat sun_mat_ambient[4] = { 0.5,0.5,0.5,0.0 };  // 环境光
    GLfloat sun_mat_diffuse[4] = { 1.0,1.0,1.0,1.0 };  // 漫反射
    GLfloat sun_mat_specular[4] = { 1.0,1.0,1.0,1.0 }; // 镜面反射
    GLfloat sun_mat_shininess[] = { 100.0 };           // 光泽度指数
    //GLfloat sun_mat_emission[4] = { 0.7,0.7,0.7,1.0 }; // 自发光

    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, sun_mat_ambient);   // 材质设定
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, sun_mat_diffuse);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, sun_mat_specular);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, sun_mat_shininess);
    //glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, sun_mat_emission);

}
void light_center()
{

    GLfloat light_position1[] = { 2.0, 0.0, 0.0, 1.0 };   // 光源位置
    GLfloat light_position2[] = { 0.0, 2.0,0.0, 1.0 };   // 光源位置
    GLfloat light_position3[] = { 0.0, -2.0,0.0, 1.0 };   // 光源位置
    GLfloat light_position4[] = { 0.0, 0.0,2.0, 1.0 };   // 光源位置
    GLfloat light_position5[] = { 0.0, 0.0,-2.0, 1.0 };   // 光源位置
    GLfloat light_position6[] = { -2.0, 0.0,0.0, 1.0 };   // 光源位置

    GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };

    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);     // 创建光源
    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT2, GL_POSITION, light_position2);     // 创建光源
    glLightfv(GL_LIGHT2, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT3, GL_POSITION, light_position3);     // 创建光源
    glLightfv(GL_LIGHT3, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT4, GL_POSITION, light_position4);     // 创建光源
    glLightfv(GL_LIGHT4, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT5, GL_POSITION, light_position5);     // 创建光源
    glLightfv(GL_LIGHT5, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT6, GL_POSITION, light_position6);     // 创建光源
    glLightfv(GL_LIGHT6, GL_DIFFUSE, light_diffuse);


    //// 设置常数衰减因子为1.0
    //glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1);
    //// 设置线性衰减因子为0.1
    //glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.1);
    //// 设置二次衰减因子为0.01
    //glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.01);

    GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
    GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
    GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 };
    GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
    GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat no_shininess[] = { 0.0 };
    GLfloat low_shininess[] = { 5.0 };
    GLfloat high_shininess[] = { 100.0 };
    GLfloat mat_emission[] = { 0.3, 0.2, 0.2, 0.0 };

    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
    glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);

}
void init()
{
    // 初始化光照和材质
    glEnable(GL_LIGHTING);
    //glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);
    glEnable(GL_LIGHT2);
    glEnable(GL_LIGHT3);
    glEnable(GL_LIGHT4);
    glEnable(GL_LIGHT5);
    glEnable(GL_LIGHT6);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_DEPTH_TEST);

    // 纹理映射
    for (int i = 0; i < 12; i++)
    {
        glGenTextures(i, &texName[i]);
        glBindTexture(GL_TEXTURE_2D, texName[i]);

        TextureImage[i] = auxDIBImageLoad(Texture_Path[i].c_str());  //加载图片

        iWidth = TextureImage[i]->sizeX;
        iHeight = TextureImage[i]->sizeY;
        pImg = TextureImage[i]->data;

        //装载纹理
        glTexImage2D(GL_TEXTURE_2D, 0, 3, iWidth, iHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pImg);

        //纹理过滤、纹理裁剪
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        //纹理环境
        glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    }
    for (int i = 0; i < 6; i++)
    {
        glGenTextures(i, &skyboxTextures[i]);
        glBindTexture(GL_TEXTURE_2D, skyboxTextures[i]);
        skyTextureImage[i] = auxDIBImageLoad(skyTexture_Path[i].c_str());  //加载图片

        iWidth = skyTextureImage[i]->sizeX;
        iHeight = skyTextureImage[i]->sizeY;
        pImg = skyTextureImage[i]->data;

        //装载纹理
        glTexImage2D(GL_TEXTURE_2D, 0, 3, iWidth, iHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pImg);

        //纹理过滤、纹理裁剪
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        //纹理环境
        glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    }
}


//处理鼠标按下事件
void processMouse(int button, int state, int x, int y)
{    //鼠标左键按下        
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
    {
        LastX = x;
        LastY = y;
        IsLBDown = TRUE;
    }
    //鼠标左键弹起
    else
    {
        IsLBDown = FALSE;
    }
}

//处理鼠标拖动事件
void processMouseActiveMotion(int x, int y)
{
    if (IsLBDown)       //若鼠标左键被按下
    {
        xrot += GLfloat(y - LastY) / GLfloat(5.0);
        yrot += GLfloat(x - LastX) / GLfloat(5.0);

        LastX = x;
        LastY = y;
        glutPostRedisplay();
    }
}
void Makebackground()
{
    for (int i = 0; i < bs_number; i++)
    {

        vec3 point = randomPointOnSphere(100.0f);
        backstar[i].x = point.x;
        backstar[i].y = point.y;
        backstar[i].z = point.z;
    }
}
void Drawbackground()
{
    glEnable(GL_POINT_SPRITE); // 启用点精灵
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // 设置混合模式
    glPushMatrix();

    for (int i = 0; i < bs_number; i++)
    {
        glPointSize(2.0); // 增加粒子大小为5.0
        glBegin(GL_POINTS);
        glColor3f(0.8, 0.8, 1.0);
        glVertex3f(backstar[i].x, backstar[i].y, backstar[i].z);
        //cout << backstar[i].x << ' ' << backstar[i].y << ' ' << backstar[i].z << '\n';

        glEnd();
    }
    glPopMatrix();
    glDisable(GL_POINT_SPRITE); // 禁用点精灵
}

void Makexxx()
{
    int inner = ceil(planet[4].orbitRadius), outer = floor(planet[5].orbitRadius);

    std::mt19937 gen;

    // 正态分布参数：均值（mean）和标准差（stddev）
    double mean = (inner + outer - 5) / 2.0;   // 均值
    double stddev = 1.0; // 标准差

    // 创建一个正态分布的随机数生成器
    std::normal_distribution<> d(mean, stddev);

    for (int i = 0; i < xxx_number; i++)
    {
        // 轨道半径
        //xxxs[i].orbitRadius = inner + (rand() % ((outer - inner) * 100)) / 1000.0;
        xxxs[i].orbitRadius = d(gen);
        if (xxxs[i].orbitRadius < inner + 0.1) xxxs[i].orbitRadius = inner + 0.1;
        if (xxxs[i].orbitRadius > 1000) xxxs[i].orbitRadius = (outer - inner) / 10.0;
        // 公转速度
        xxxs[i].angularVelocity = base_gz * 365 / float(800.0 + rand() % 500);
        // 开始角度
        xxxs[i].angle = radians(rand() % 360);
        // 半径
        xxxs[i].radius = (1 + rand() % 20) / 10.0;

        xxxs[i].x = xxxs[i].orbitRadius * cos(xxxs[i].angle);
        xxxs[i].y = xxxs[i].orbitRadius * sin(xxxs[i].angle);
        xxxs[i].z = (rand() % 8) / 10.0;
    }
}
void Drawxxx()
{
    glEnable(GL_POINT_SPRITE); // 启用点精灵
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // 设置混合模式
    glPushMatrix();

    for (int i = 0; i < xxx_number; i++)
    {
        glPointSize(xxxs[i].radius); // 增加粒子大小为5.0
        glBegin(GL_POINTS);
        glColor3f(1.0, 1.0, 0.8);
        glVertex3f(xxxs[i].x, xxxs[i].y, xxxs[i].z);
        glEnd();
    }
    glPopMatrix();
    glDisable(GL_POINT_SPRITE); // 禁用点精灵
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("太阳系模拟");

    // 初始化光照和材质
    srand(static_cast<unsigned int>(time(0))); // 设置随机数种子
    init();
    music();
    //Drawxxx();
    Makexxx();
    Makebackground();
    glutTimerFunc(1000 / fps, updatePositions, 0); // 更新
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutSpecialFunc(specialKey);
    glutKeyboardFunc(keyboard);
    glutMouseFunc(processMouse);
    glutMotionFunc(processMouseActiveMotion);
    //glutMouseWheelFunc(mouseWheel);
    createGLUTMenus();
    glutMainLoop();
    return 0;
}



/*
以下是太阳系各行星的轨道参数：

1. **水星**：
   - 轨道半径：0.3871 AU（5791万千米）
   - 轨道倾角：7.005度
   - 公转周期：87.97天
   - 自转周期：59天

2. **金星**：
   - 轨道半径：0.7233 AU（108,208,930千米）
   - 轨道倾角：3.395度
   - 公转周期：224.701天
   - 自转周期：243天（逆行）

3. **地球**：
   - 轨道半径：1.0000 AU（149,597,870千米）
   - 轨道倾角：0.000度
   - 公转周期：365.26天
   - 自转周期：23小时56分钟

4. **火星**：
   - 轨道半径：1.5237 AU（227,940,000千米）
   - 轨道倾角：1.850度
   - 公转周期：687天
   - 自转周期：24小时37分钟

5. **木星**：
   - 轨道半径：5.2026 AU（778,340,820千米）
   - 轨道倾角：1.303度
   - 公转周期：11.86年
   - 自转周期：9小时50分钟

6. **土星**：
   - 轨道半径：9.5549 AU（1,429,400,000千米）
   - 轨道倾角：2.489度
   - 公转周期：29.46年
   - 自转周期：10小时39分钟

7. **天王星**：
   - 轨道半径：19.2184 AU（2,870,990,000千米）
   - 轨道倾角：0.773度
   - 公转周期：84.01年
   - 自转周期：17小时14分钟

8. **海王星**：
   - 轨道半径：30.1104 AU（4,504,000,000千米）
   - 轨道倾角：1.770度
   - 公转周期：164.82年
   - 自转周期：16小时06分钟

1. **太阳**：
   - 轨道半径：0 AU（太阳系中心位置）
   - 轨道倾角：无（作为太阳系中心天体，定义其轨道倾角不适用）
   - 公转周期：无（太阳相对太阳系质心基本静止，公转周期概念在此不适用）
   - 自转周期：约25 - 35天（太阳不同纬度自转周期不同，赤道附近约25天，两极附近约35天）
2. **月球**：
   - 轨道半径：0.00257 AU（约384,400千米，相对于地球）
   - 轨道倾角：约5.145度（相对于地球赤道平面）
   - 公转周期：约27.32天（相对于恒星，称为恒星月）
   - 自转周期：约27.32天（月球自转周期和公转周期相同，所以我们始终只能看到月球的一面）
*/