Qt下的OpenGL 编程（10）Solar System

最新推荐文章于 2021-05-01 18:42:39 发布
最新推荐文章于 2021-05-01 18:42:39 发布 · 327 阅读 · 0

本文详细介绍了使用OpenGL进行太阳系模拟的编程实践，包括星球类的设计、程序结构搭建及动画实现。通过构建9个球体并赋予不同材质，模拟各行星的公转与自转，最终达到类似iPad应用SolarSystem的效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、提要
    今天的内容是OpenGL的编程实践—太阳系的模拟！
     红宝书上有相应的教程，但这里我们要实现得更全面一些。iPad上有一个很棒的应用，名字叫Solar System，我们尽量去达到它的效果。
    先来看一下最终效果：
   、




 



 



 

 

思路：
 

     建立9个球体，分别赋予不同的材质，再通过动画不断变换它们的位置，就可以实现模拟了。
 



 

 

二、有关太阳系的知识
 

     太阳系有一颗恒星：太阳，8颗行星：水，金，地，火，木，土，天王，海王。9颗星球的位置如下：
 

 



 



 

 

 

    然后去搜集了解一下各个星球的自转和公转周期，脑袋里面有个概念。
 

    接着可以去找一些星球贴图的素材了，我在网上找到了一些资源，太阳的贴图是自己用ps绘制的，然后把它们通通添加到资源文件中，就像这样：
 

    
 



 

 

三、程序结构
 

    相比与之前的框架，这里添加了一个星球类，文件结构如下：
 

     程序还是比较清晰，直接贴代码了：
 

     


/*
-----------------------------------------------------------------------------
Filename:   star.h
-----------------------------------------------------------------------------
//星球类
-----------------------------------------------------------------------------
  */
#ifndef STAR_H
#define STAR_H
#include <QtOpenGL>
#include <GL/glut.h>
class Star
{
public:
    Star();
    Star(int tex,GLfloat r,GLfloat x,GLfloat y,GLfloat revS,GLfloat rotS,GLfloat a[], GLfloat d[], GLfloat p[],GLfloat s);
    ~Star();
    //公转
    void revolute();
    //自转
    void rotate();
    //星球半径
    float radious;
    //星球位置
    GLfloat disX;
    GLfloat disY;
    //纹理id
    int texId;
    //环境反射光
    GLfloat *ambient;
    //漫反射
    GLfloat *diffuse;
    //镜面反射
    GLfloat *specular;
    //镜面反射强度
    GLfloat shinniness;
    //公转速度
    GLfloat revSpeed;
    //自转速度
    GLfloat rotSpeed;
    //公转角度
    float revAngle;
    //自转角度
    float rotAngle;
    /*  //公转周期
    float revPeriod;
    //自转周期
    float rotPeriod;
    
    
    
    //纹理属性
    GLfloat WRAP_S;
    GLfloat WRAP_T;
    GLfloat MAG_FILTER;
    GLfloat MIN_FILTER;
    GLfloat ENV_MODE;
    */
};

#endif // STAR_H



 



/*
-----------------------------------------------------------------------------
Filename:   star.cpp
-----------------------------------------------------------------------------
//星球类
-----------------------------------------------------------------------------
  */
#include "star.h"

Star::Star()
{
}
Star::Star(int tex, GLfloat r, GLfloat x, GLfloat y, GLfloat revS, GLfloat rotS, GLfloat a[], GLfloat d[], GLfloat p[], GLfloat s)
{
    this->texId=tex;
    this->radious=r;
    this->disX=x;
    this->disY=y;
    this->ambient=a;
    this->diffuse=d;
    this->specular=p;
    this->shinniness=s;
    this->revSpeed=revS;
    this->rotSpeed=rotS;
    this->revAngle=0.0;
    this->rotAngle=0.0;
    
}
Star::~Star()
{}
void Star::revolute()
{
    this->revAngle= this->revAngle + this->revSpeed< 360 ? this->revAngle + this->revSpeed: 0;
}
void Star::rotate()
{
    this->rotAngle= this->rotAngle + this->rotSpeed< 360 ? this->rotAngle + this->rotSpeed: 0;
}





/*
-----------------------------------------------------------------------------
Filename:   nehewidget.h
-----------------------------------------------------------------------------
//opengl渲染窗口类
-----------------------------------------------------------------------------
  */
#ifndef NEHEWIDGET_H
#define NEHEWIDGET_H

#include <QGLWidget>
#include <QtGui>
#include <QtOpenGL>
#include <QtCore>
#include <GL/glut.h>
#include<iostream>
#include "star.h"
#define PI 3.14159265
class NeHeWidget : public QGLWidget
{
    Q_OBJECT
public:
    explicit NeHeWidget(QWidget *parent = 0);
    ~NeHeWidget();
    void zoomOut();
    void zoomIn();
    void enableBlend();
    void disableBLend();
    void calFrequency();
    void speedUp();
    void speedDown();
    void eyeXup();
    void eyeXdown();
    void eyeZup();
    void eyeZdown();
protected:
    //设置渲染环境
    void initializeGL();
    //绘制窗口
    void paintGL();
    //响应窗口的大小变化
    void resizeGL( int width, int height );
    //加载纹理
    void loadGLTextures(QString filename,int id);
    //绘制星球
    void drawStar(Star *s);
    //材质设置
    void setMaterial(Star *s);
    //正方体在三个方向上的旋转
    
    QFont fpsFont;
    GLfloat xRot, yRot, zRot;
    //纹理存储数组
    GLuint texture[13];
    //场景深入屏幕的距离
    GLfloat zoom;
    //立方体在X轴和Y轴上旋转的速度
    GLfloat xSpeed, ySpeed;
    //计时器，实现动画
    QTimer *timer;
    //帧刷新时间
    int fpsSpan;
    GLfloat colorSpan;
    GLUquadricObj *mySphere;
    
    Star *sky;
    Star *sun;
    Star *mercury;
    Star *venus;
    Star *earth;
    Star *mars;
    Star *jupiter;
    Star *saturn;
    
    GLfloat eyeX;
    GLfloat eyeY;
    GLfloat eyeZ;
    
};

#endif // NEHEWIDGET_H





 



/*
-----------------------------------------------------------------------------
Filename:   nehewidget.cpp
-----------------------------------------------------------------------------
//opengl渲染窗口类
-----------------------------------------------------------------------------
  */
#include "nehewidget.h"

NeHeWidget::NeHeWidget(QWidget *parent) :
    QGLWidget(parent)
{
    xRot = yRot = zRot = 0.0;
    zoom = -5.0;
    xSpeed = ySpeed = 0.0;
    fpsFont=QFont("Times", 20);
    colorSpan=0;
    fpsSpan=50;
    timer = new QTimer(this);
    
    timer->start(fpsSpan);
    connect(timer,SIGNAL(timeout()),this,SLOT(updateGL()));
    mySphere=gluNewQuadric();
    
    eyeX=0.0;
    eyeY=0.0;
    eyeZ=190.0;
    //夜空参数设置
    GLfloat  sky_ambient[]={0.0,0.0,0.0,1.0};
    GLfloat  sky_diffuse[]={0.0,0.0,0.0,1.0};
    GLfloat  sky_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  sky_shininess=0.0;
    GLfloat  sky_radious=290.0;
    // GLfloat sky_rotSpeed= (GLfloat)360/58/100;
    sky=new Star(0,sky_radious,0,0,0,0,sky_ambient,sky_diffuse,sky_specular,sky_shininess);
    
    //太阳参数设置
    GLfloat  sun_ambient[]={0.0,0.0,0.0,1.0};
    GLfloat  sun_diffuse[]={0.0,0.0,0.0,1.0};
    GLfloat  sun_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  sun_shininess=20.0;
    GLfloat  sun_radious=10.0;
    GLfloat sun_rotSpeed= (GLfloat)360/58/100;
    sun=new Star(1,sun_radious,0,0,0,sun_rotSpeed,sun_ambient,sun_diffuse,sun_specular,sun_shininess);
    
    //水星
    GLfloat  mercury_ambient[]={0.0,0.0,0.0,1.0};
    GLfloat  mercury_diffuse[]={0.5,0.5,0.5,1.0};
    GLfloat  mercury_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  mercury_shininess=20.0;
    GLfloat  mercury_radious=0.7;
    GLfloat mecury_revSpeed=(GLfloat)360/88;
    GLfloat mecury_rotSpeed= (GLfloat)360/58/100;
    mercury=new Star(2,mercury_radious,15.2,0,mecury_revSpeed,mecury_rotSpeed,mercury_ambient,mercury_diffuse,mercury_specular,mercury_shininess);
    
    //金星
    GLfloat  venus_ambient[]={0.0,0.0,0.0,1.0};
    GLfloat  venus_diffuse[]={0.8,0.8,0.8,1.0};
    GLfloat  venus_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  venus_shininess=20.0;
    GLfloat  venus_radious=1.24;
    GLfloat venus_revSpeed=(GLfloat)360/224;
    GLfloat venus_rotSpeed= (GLfloat)360/243/100;
    venus=new Star(3,venus_radious,19.2,0,venus_revSpeed,venus_rotSpeed,venus_ambient,venus_diffuse,venus_specular,venus_shininess);
    
    //地球
    GLfloat  earth_ambient[]={0.1,0.1,0.1,1.0};
    GLfloat  earth_diffuse[]={0.4,0.4,0.8,1.0};
    GLfloat  earth_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  earth_shininess=20.0;
    GLfloat  earth_radious=1.24;
    GLfloat earth_revSpeed=(GLfloat)360/365;
    GLfloat earth_rotSpeed= (GLfloat)360/1/100;
    earth=new Star(4,earth_radious,26,0,earth_revSpeed,earth_rotSpeed,earth_ambient,earth_diffuse,earth_specular,earth_shininess);
    
    //火星
    GLfloat  mars_ambient[]={0.1,0.1,0.1,1.0};
    GLfloat  mars_diffuse[]={0.6, 0.6, 0.6, 1.0};
    GLfloat  mars_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  mars_shininess=20.0;
    GLfloat  mars_radious=1.0;
    GLfloat mars_revSpeed=(GLfloat)360/687;
    GLfloat mars_rotSpeed= (GLfloat)360/1/100;
    mars=new Star(5,mars_radious,31,0,mars_revSpeed,mars_rotSpeed,mars_ambient,mars_diffuse,mars_specular,mars_shininess);
    
    //木星
    GLfloat  jupiter_ambient[]={0.0, 0.0, 0.0,1.0};
    GLfloat  jupiter_diffuse[]={0.6, 0.6, 0.6, 1.0};
    GLfloat  jupiter_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  jupiter_shininess=20.0;
    GLfloat  jupiter_radious=4.0;
    GLfloat jupiter_revSpeed=(GLfloat)360/4329;
    GLfloat jupiter_rotSpeed= (GLfloat)360/0.3/100;
    jupiter=new Star(6,jupiter_radious,43,0,jupiter_revSpeed,jupiter_rotSpeed,jupiter_ambient,jupiter_diffuse,jupiter_specular,jupiter_shininess);
    //土星
    GLfloat  saturn_ambient[]={0.0, 0.0, 0.0,1.0};
    GLfloat  saturn_diffuse[]={0.6, 0.6, 0.6, 1.0};
    GLfloat  saturn_specular[]={0.0,0.0,0.0,1.0};
    GLfloat  saturn_shininess=20.0;
    GLfloat  saturn_radious=3.5;
    GLfloat saturn_revSpeed=(GLfloat)360/10768;
    GLfloat saturn_rotSpeed= (GLfloat)360/1.4/100;
    saturn=new Star(7,saturn_radious,56.5,0,saturn_revSpeed,saturn_rotSpeed,saturn_ambient,saturn_diffuse,saturn_specular,saturn_shininess);
    
    
}
NeHeWidget::~NeHeWidget()
{}
void NeHeWidget::loadGLTextures(QString filename, int id)
{
    QImage tex, buf;
    if ( !buf.load(filename ) )
    {
        //如果载入不成功，自动生成一个128*128的32位色的绿色图片。
        qWarning("Could not read image file!");
        QImage dummy( 128, 128,QImage::Format_RGB32 );
        dummy.fill( Qt::green );
        buf = dummy;
    }
    //转换成纹理类型
    tex = QGLWidget::convertToGLFormat( buf );
    //创建纹理
    glGenTextures( 1, &texture[id] );
    //使用来自位图数据生成的典型纹理,将纹理名字texture[0]绑定到纹理目标上
    glBindTexture( GL_TEXTURE_2D, texture[id] );
    glTexImage2D( GL_TEXTURE_2D, 0, 3, tex.width(), tex.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, tex.bits() );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
}
void NeHeWidget::drawStar(Star *s)
{
    glPushMatrix();
    //公转
    glRotatef(s->revAngle,0.0,0.0,1.0);
    glTranslatef(s->disX, s->disY, 0.0);
    //自转
    glRotatef(s->rotAngle,0.0,0.0,1.0);
    gluSphere(mySphere, s->radious, 32, 16);
    //设置材质属性
    glMaterialfv(GL_BACK, GL_AMBIENT, s->ambient);
    glMaterialfv(GL_BACK, GL_DIFFUSE, s->diffuse);
    glMaterialfv(GL_BACK, GL_SPECULAR, s->specular);
    glMaterialf(GL_BACK, GL_SHININESS, s->shinniness);
    //
    glPopMatrix();
}
void NeHeWidget::setMaterial(Star *s)
{
    
}

void NeHeWidget::initializeGL()
{
    //载入纹理
    loadGLTextures( ":/data/sun.jpg",sun->texId);
    loadGLTextures( ":/data/mercury.bmp",mercury->texId);
    loadGLTextures( ":/data/venus.jpg",venus->texId);
    loadGLTextures( ":/data/earth2.jpg",earth->texId);
    loadGLTextures( ":/data/mars.bmp",mars->texId);
    loadGLTextures( ":/data/saturn.jpg",saturn->texId);
    loadGLTextures( ":/data/jupiter.bmp",jupiter->texId);
    loadGLTextures( ":/data/sky.jpg",sky->texId);
    //loadGLTextures( ":/data/neptune.bmp",neptune->texId);
    
    // 启用阴影平滑
    glShadeModel( GL_SMOOTH );
    // 黑色背景
    glClearColor( 0.0, 0.0, 0.0, 0.0 );
    // 设置深度缓存
    glClearDepth( 1.0 );
    // 启用深度测试
    glEnable( GL_DEPTH_TEST );
    //启用纹理
    glEnable( GL_TEXTURE_2D );
    // 所作深度测试的类型
    glDepthFunc( GL_LEQUAL );
    // 告诉系统对透视进行修正
    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
    //    开启剔除操作效果
    //glEnable(GL_CULL_FACE);
    // 使用平滑法线
    gluQuadricNormals(mySphere, GL_SMOOTH);
    // 使用纹理
    gluQuadricTexture(mySphere, GL_TRUE);
    // 设置球纹理映射
    
}
void NeHeWidget::paintGL()
{
    
    // 清除屏幕和深度缓存
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    //glRotatef( yRot, 0.0,  0.0,  1.0 );
    glColor3f(1.0,1.0,1.0);
    glBindTexture(GL_TEXTURE_2D, texture[sky->texId]);
    drawStar(sky);
    
    glBindTexture(GL_TEXTURE_2D, texture[sun->texId]);
    drawStar(sun);
    
    glBindTexture(GL_TEXTURE_2D, texture[mercury->texId]);
    drawStar(mercury);
    
    glBindTexture(GL_TEXTURE_2D, texture[venus->texId]);
    drawStar(venus);
    
    glBindTexture(GL_TEXTURE_2D, texture[earth->texId]);
    drawStar(earth);
    
    glBindTexture(GL_TEXTURE_2D, texture[mars->texId]);
    drawStar(mars);
    
    glBindTexture(GL_TEXTURE_2D, texture[jupiter->texId]);
    drawStar(jupiter);
    
    glBindTexture(GL_TEXTURE_2D, texture[saturn->texId]);
    drawStar(saturn);
    
    
    //旋转速度
    yRot += 0.4;
    sun->rotate();
    mercury->revolute();
    mercury->rotate();
    venus->revolute();
    venus->rotate();
    earth->revolute();
    earth->rotate();
    mars->revolute();
    mars->rotate();
    jupiter->revolute();
    jupiter->rotate();
    saturn->revolute();
    saturn->rotate();
    glLoadIdentity();
    gluLookAt (eyeX, eyeY, eyeZ, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0);
    // gluLookAt (80.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0);
    glFlush();
    //fps的字体颜色
    glColor3f(0.0f,0.0f,1.0f);
    //计算FPS
    calFrequency();
    
}
// 重置OpenGL窗口大小
void NeHeWidget::resizeGL(int width, int height)
{
    // 防止窗口大小变为0
    if ( height == 0 )
    {
        height = 1;
    }
    // 重置当前的视口
    glViewport( 0, 0, (GLint)width, (GLint)height );
    // 选择投影矩阵
    glMatrixMode( GL_PROJECTION );
    // 重置投影矩阵
    glLoadIdentity();
    // 设置视口的大小
    gluPerspective( 45.0, (GLfloat)width/(GLfloat)height, 0.1, 600.0 );
    // 选择模型观察矩阵
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
}
void NeHeWidget::speedUp()
{
    fpsSpan+=1;
    qDebug()<<fpsSpan;
    timer->setInterval(fpsSpan);
    //timer->start(fpsSpan);
    updateGL();
}
void NeHeWidget::speedDown()
{
    if(fpsSpan>1) fpsSpan-=1;
    else fpsSpan=1;
    qDebug()<<fpsSpan;
    timer->setInterval(fpsSpan);
    updateGL();
}
void NeHeWidget::eyeXup()
{
    eyeX+=1;
}
void NeHeWidget::eyeXdown()
{
    // if(eyeX>10) eyeX-=1;
    //else eyeX=10;
    eyeX-=1;
}
void NeHeWidget::eyeZup()
{
    eyeZ+=1;
}
void NeHeWidget::eyeZdown()
{
    // if(eyeX>10) eyeX-=1;
    //else eyeX=10;
    eyeZ-=1;
}
void NeHeWidget::zoomOut()
{
    zoom+= 0.2;
    
    updateGL();
}
void NeHeWidget::zoomIn()
{
    zoom -= 0.2;
    updateGL();
}
void NeHeWidget::calFrequency()
{
    static  QString tmp="";
    static float framesPerSecond=0.0f;//fps的数值
    static float frames    = 0.0f;       // 用于存储渲染的帧数
    static float lastTime   = 0.0f;       // 前一秒的时刻
    float currentTime =  glutGet(GLUT_ELAPSED_TIME)* 0.001f;//程序运行的时间
    ++frames;
    if( currentTime - lastTime > 1.0f )//，每秒刷新一次
    {
        framesPerSecond=frames;
        tmp.setNum(framesPerSecond);
        lastTime = currentTime;
        frames= 0;
    }
    renderText(100,100,"FPS: "+tmp,fpsFont);//最终结果在窗口中渲染
}







/*
-----------------------------------------------------------------------------
Filename:   mainwindow.h
-----------------------------------------------------------------------------
//主窗口类
-----------------------------------------------------------------------------
  */

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QtGui/QMainWindow>
#include <QKeyEvent>
#include "nehewidget.h"
class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
protected:
    bool fullscreen;
    //处理键盘事件
    void keyPressEvent( QKeyEvent *e );
private:
    NeHeWidget *neheWidget ;
};

#endif // MAINWINDOW_H






/*
-----------------------------------------------------------------------------
Filename:   mainwindow.cpp
-----------------------------------------------------------------------------
//主窗口类
-----------------------------------------------------------------------------
  */
#include "mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    neheWidget = new NeHeWidget();
    fullscreen = true;
    setGeometry(100,100,1000,768);
    setWindowTitle(tr("NeHe's OpenGL Framework"));
    setCentralWidget(neheWidget);
}

MainWindow::~MainWindow()
{
    
}
void MainWindow::keyPressEvent(QKeyEvent *e)
{
    switch ( e->key() )
    {
    case Qt::Key_F2:
        fullscreen = !fullscreen;
        if ( fullscreen )
        {
            showFullScreen();
        }
        else
        {
            showNormal();
        }
        neheWidget->updateGL();
        break;
    case Qt::Key_Escape:
        close();
        break;
    case Qt::Key_PageUp:
        neheWidget->zoomOut();
        break;
    case Qt::Key_PageDown:
        neheWidget->zoomIn();
        break;
    case Qt::Key_Down:
        neheWidget->speedUp();
        break;
    case Qt::Key_Up:
        neheWidget->speedDown();
        break;
    case Qt::Key_W:
        neheWidget->eyeXup();
        break;
    case Qt::Key_S:
        neheWidget->eyeXdown();
        break;
    case Qt::Key_E:
        neheWidget->eyeZup();
        break;
    case Qt::Key_D:
        neheWidget->eyeZdown();
        break;
    }
}






//main函数
#include <QtGui/QApplication>
#include "mainwindow.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    glutInit(&argc, argv);
    w.show();
    
    return a.exec();
}





 


四。程序中未完善的地方


  这个程序应该只能算是一个大致的框架，还是有很多地方可以改进，比如：添加天王星，海王星，冥王星，添加每个星球的倾角，添加月球....


有兴趣的同学可以继续完善，我们可以继续讨论。


 


 参考资料




1.《OpenGL Reference Manual》，OpenGL参考手册


2.《OpenGL编程指南》（《OpenGL Programming Guide》），Dave Shreiner，Mason Woo，Jackie Neider，Tom Davis著，徐波译，机械工业出版社

3. 《win32 OpenGL编程 》 一个大牛的博客 
http://blog.youkuaiyun.com/vagrxie/article/category/628716/3
 


 

 

 

 

 

 


                

        




    

    
  



    

      

        

            

              
                
                  iteye_17686
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
用qt看看我们的太阳系（官方例子）

				
			

			

				

					西门吹雪
				

				

					12-05
					
					572
					
				

			

		

		

			
				
偶然在qt的官方示例中看到了一个基于qml实现的特别好玩的例子
在这里简要截图显示
太阳自转展示
水星

金星
地球
世界地图




			
		

	



                

            
              



	

		

			

				
					
QT实现太阳系系统八大行星

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					01-05
					
					1090
					
				

			

		

		

			
				
QT实现太阳系系统八大行星

			
		

	



              


  
              

                


	

		

			

				
					
Qt下openGL编程

				
			

			

				

					08-02
				

			

		

		

			
				
这是Qt结合openGL的小程序，功能比较简单，仅供新手学习。本程序开发环境：Qt Creator4.0.2+Qt5.7
注：如果程序运行出错，那是因为缺少glut库。可以参考下面链接解决：http://www.cnblogs.com/BlueSky2012/articles/2507107.html

			
		

	





	

		

			

				
					
Qt下 用OpenGL 实现的模拟太阳系

				
			

			

				

					05-13
				

			

		

		

			
				
这个小程序是用Qt+OpenGL做的。
可以直接运行，是仿照Nehe教程中的做的。
网上学习都说OpenGL的最好教程是NeHe。
但是Windows编程很难，也很落后。
对于想学习OpenGL的人来说很有参考价值。

			
		

	



		

			
		



	

		

			

				
					
OpenGL实现模拟太阳系

				
			

			

				

					12-11
				

			

		

		

			
				
OpenGL实现模拟太阳系
地球可以绕着太阳转
月球可以绕着地球转
同时还考虑到了黄赤交角的问题

			
		

	





	

		

			

				
					
opengl实现的太阳系

				
			

			

				

					02-26
				

			

		

		

			
				
计算机图形学作业，利用opengl实现了一个太阳系，共有八大行星，有纹理贴图，进行了视角切换比较真实。 计算机图形学作业，利用opengl实现了一个太阳系，共有八大行星，有纹理贴图，进行了视角切换比较真实。

			
		

	





	

		

			

				
					
Qt_Opengl_NeHe.rar_NeHe qt_cGUIQt4编程_opengl_qt+opengl_visual c

				
			

			

				

					09-23
				

			

		

		

			
				
"Qt_Opengl_NeHe.rar_NeHe qt_cGUIQt4编程_opengl_qt+opengl_visual c" 这个标题暗示了我们即将探讨的内容是关于Qt框架下的OpenGL编程，结合了NeHe教程，适用于C++ GUI开发，并且提到了Visual C++ 2005作为编译环境...

			
		

	





	

		

			

				
					
linux编译qt opengl,动手搭建Qt下的OpenGL编程框架

				
			

			

				

					weixin_32445895的博客
				

				

					05-01
					
					1175
					
				

			

		

		

			
				
一、 提要在前面的一篇文章我们已经配置好了opengl的编程环境，今天要做的就是搭建一个Qt的编程框架，方便后面的学习。这一节会涉及到一些OpenGL的基础方法，多用手册和搜索引擎去理解。二、 框架结构项目的结构如下图。主要的思路是：mainwindow类用来处理程序的逻辑和交互，nehewidget是继承QGLWidget的，用来绘制Opengl。在.pro文件中一定要加入QT+= o...

			
		

	





	

		

			

				
					
基于Qt的OpenGL编程并能实现相应按钮点击事件

				
			

			

				

					09-13
				

			

		

		

			
				
这是我的毕设题目中写的软件，基本功能是输入数据，就会在opengl框中绘制图像，用到了matlab，opengl，是基于qt开发的（vs2013中的qt插件），里面都是调用到的操作opengl的方法，也是比较新的，网上有很多老的方法...

			
		

	





	

		

			

				
					
QT下openGL三维图形绘制的光照模型实现

				
			

			

				

					09-20
				

			

		

		

			
				
实现了QT下OpenGL的光源照射编程，模拟现实中的光源实现三维图形的绘制，在Vs2017+QT插件平台下运行

			
		

	





	

		

			

				
					
3D世界的QT+opengl实现

				
			

			

				

					04-22
				

			

		

		

			
				
NeHe中第10课中移动的3世界的实现

			
		

	





	

		

			

				
					
太阳系(Solar System)

				
			

			

				

					11-14
				

			

		

		

			
				
初学DirectX  第一阶段小项目实现了太阳系
程序中的按键有 WSADZX  和 上下左右 这几个键操作。
对初学者有帮助，里面有许多数学变换的应用，有兴趣的朋友可以下载。

			
		

	





	

		

			

				
					
天线软件.zip_天线 方向图_天线方向_天线方向图_天线软件_方向图

				
			

			

				

					07-14
				

			

		

		

			
				
一个编写的软件，用于绘制天线方向图和辐射方向，内容比较丰富，对于进行学习和理解天线的同行有帮助

			
		

	





	

		

			

				
					
opengl 太阳系光照效果（学习笔记-仅供参考）

				
			

			

				

					qq_45228525的博客
				

				

					06-17
					
					1594
					
				

			

		

		

			
				
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>

#define WIDTH 400 
#define HEIGHT 400 
static GLfloat angle = 0.0f;

void myDisplay(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_PROJECTION);
	

			
		

	





	

		

			

				
					
Qt OpenGL教程

				
			

			

				

					weixin_34258838的博客
				

				

					11-05
					
					2232
					
				

			

		

		

			
				
Qt OpenGL教程
最近一段时间除了学习Qt，翻译Qt文档之外，由于工作和兴趣的原因，开始着手看Qt OpenGL编程。在网上搜索了有关OpenGL的教程，发现NeHe的OpenGL教程的还很不错，作者是NeHe。上面有很多种语言的实现，但是没有Qt和Gtk的，所以我就想着手写这个Qt OpenGL教程，每课的内容和NeHe是一样的。另外，介绍NeHe的一个中文翻译站点优快云-CKer翻译...

			
		

	





	

		

			

				
					
Qt下的OpenGL 编程（5）光照和纹理滤波

				
			

			

				

					weixin_33912638的博客
				

				

					08-13
					
					270
					
				

			

		

		

			
				
一、提要     今天在网上看到一个消息，芬兰IT服务公司Digia Oyj称，公司将会出资400万欧元购买诺基亚旗下QT软件业务芬兰IT服务公司Digia Oyj称，公司将会出资400万欧元购买诺基亚旗下QT软件业务。     Qt是一个非常优秀的团队，希望Qt离开Nokia之后能够发展得更好吧。     经过了上一篇的教程，我们对3D世界已经有了初步的认识，今天我们要学习...

			
		

	





	

		

			

				
					
opengGL实战——太阳系三维场景动画搭建

				
			

			

				

					尘海折柳的博客
				

				

					02-27
					
					2292
					
				

			

		

		

			
				
写在前面：最近在学习三维Opengl相关技术，做了一个太阳系三维场景的简单动画，先看一下效果图：





演示视屏：https://www.bilibili.com/video/BV1HK4y1D7pM

界面采用Qt进行搭建，主要的渲染绘制过程如下：

1.球体的绘制函数：


glPushMatrix();
	if (m_enableOrbit)
	{
		glDisable(GL_LIGHTING);
		glColor3d(0.5, 0.5, 0.5);
		glBegin(GL_LINE_LOO

			
		

	





	

		

			

				
					
openGL绘制太阳系

				
			

			

				

					柠萌味
				

				

					02-11
					
					5705
					
				

			

		

		

			
				
 #include "stdafx.h"#include&lt;windows.h&gt;#include "gl.h"#include "glut.h"#include&lt;stdlib.h&gt;#include&lt;stdio.h&gt;//行星GLfloat rot0 = 30.0;GLfloat rot1 = 0.0;GLfloat rot2 = 0.0;GLfloat rot3 =..

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值