Lane-学习OpenGL(4)-4个进阶例子

最新推荐文章于 2023-01-05 17:34:22 发布
最新推荐文章于 2023-01-05 17:34:22 发布
阅读量1.8k 收藏 6
点赞数
分类专栏： OpenGL C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lane_l/article/details/42024659
版权
C++ 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
OpenGL
4 篇文章 0 订阅
订阅专栏
本文介绍了在OpenGL环境下进行图形渲染的四个高级实例，包括纹理贴图的棋盘效果、纹理子图像的替换、利用求值器进行纹理处理以及NURBS非均匀有理B样条表面的创建。通过这些实例，深入理解OpenGL的纹理技术和高级图形绘制技术。
摘要由CSDN通过智能技术生成

运行环境:

(1)Windows 7

(2)CodeBlocks

(3)GLUT

(4)Author:Lane

2014-12-19

1.经过纹理贴图的棋盘

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

#include <cstdlib>
#include <cstdio>
#include <cmath>

#define checkImageWidth 64
#define checkImageHeight 64
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];

static GLuint texName;

void makeCheckImage(void){
    int i,j,c;
    for(i = 0; i < checkImageHeight; i++){
        for(j = 0; j < checkImageWidth; j++){
            c = (((i&0x8)==0)^((j&0x8))==0)*255;
            checkImage[i][j][0] = (GLubyte)c;
            checkImage[i][j][1] = (GLubyte)c;
            checkImage[i][j][2] = (GLubyte)c;
            checkImage[i][j][3] = (GLubyte)255;
        }
    }
}

void init(void){
    glClearColor(0.0,0.0,0.0,0.0);
    glShadeModel(GL_FLAT);
    glEnable(GL_DEPTH_TEST);
    makeCheckImage();
    glPixelStorei(GL_UNPACK_ALIGNMENT,1);
    glGenTextures(1,&texName);
    glBindTexture(GL_TEXTURE_2D,texName);

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,checkImageWidth,checkImageHeight,0,GL_RGBA,GL_UNSIGNED_BYTE,checkImage);
}

void display(void){
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    glEnable(GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
    glBindTexture(GL_TEXTURE_2D,texName);
    glBegin(GL_QUADS);
        glTexCoord2f(0.0,0.0);
        glVertex3f(-2.0,-1.0,0.0);
        glTexCoord2f(0.0,1.0);
        glVertex3f(-2.0,1.0,0.0);
        glTexCoord2f(1.0,1.0);
        glVertex3f(0.0,1.0,0.0);
        glTexCoord2f(1.0,0.0);
        glVertex3f(0.0,-1.0,0.0);

        glTexCoord2f(0.0,0.0);
        glVertex3f(1.0,-1.0,0.0);
        glTexCoord2f(0.0,1.0);
        glVertex3f(1.0,1.0,0.0);
        glTexCoord2f(1.0,1.0);
        glVertex3f(2.41421,1.0,-1.41421);
        glTexCoord2f(1.0,0.0);
        glVertex3f(2.41421,-1.0,-1.41421);
    glEnd();
    glFlush();
    glDisable(GL_TEXTURE_2D);
}

void reshape(int w,int h){
    glViewport(0,0,(GLsizei)w,(GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0,(GLfloat)w/(GLfloat)h,1.0,30.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0,0.0,-3.6);
}

int main(int argc,char** argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
    glutInitWindowSize(256,256);
    glutInitWindowPosition(100,100);
    glutCreateWindow(argv[0]);
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    //glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

2.替换纹理子图像

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

#include <cstdlib>
#include <cstdio>
#include <cmath>

#define checkImageWidth 64
#define checkImageHeight 64

#define subImageWidth 16
#define subImageHeight 16

static GLubyte checkImage[checkImageHeight][checkImageWidth][4];

static GLubyte subImage[subImageHeight][subImageWidth][4];

static GLuint texName;

void makeCheckImage(void){
    int i,j,c;
    for(i = 0; i < checkImageHeight; i++){
        for(j = 0; j < checkImageWidth; j++){
            c = (((i&0x8)==0)^((j&0x8))==0)*255;
            checkImage[i][j][0] = (GLubyte)c;
            checkImage[i][j][1] = (GLubyte)c;
            checkImage[i][j][2] = (GLubyte)c;
            checkImage[i][j][3] = (GLubyte)255;
        }
    }

    for(i = 0; i < subImageHeight; i++){
        for(j = 0; j < subImageWidth; j++){
            c = (((i&0x4)==0)^((j&0x4)==0)*255);
            subImage[i][j][0] = (GLubyte)c;
            subImage[i][j][1] = (GLubyte)0;
            subImage[i][j][2] = (GLubyte)0;
            subImage[i][j][3] = (GLubyte)255;
        }
    }
}

void keyboard(unsigned char key,int x,int y){
    switch(key){
        case 's':
        case 'S':
            glBindTexture(GL_TEXTURE_2D,texName);
            glTexSubImage2D(GL_TEXTURE_2D,0,12,44,
                            subImageWidth,subImageHeight,GL_RGBA,
                            GL_UNSIGNED_BYTE,subImage);
            glutPostRedisplay();
            break;
        case 'r':
        case 'R':
            glBindTexture(GL_TEXTURE_2D,texName);
            glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,
                         checkImageWidth,checkImageHeight,0,
                         GL_RGBA,GL_UNSIGNED_BYTE,checkImage);
            glutPostRedisplay();
            break;
        case 27:
            exit(0);
            break;
        default:
            break;
    }
}

void init(void){
    glClearColor(0.0,0.0,0.0,0.0);
    glShadeModel(GL_FLAT);
    glEnable(GL_DEPTH_TEST);
    makeCheckImage();
    glPixelStorei(GL_UNPACK_ALIGNMENT,1);
    glGenTextures(1,&texName);
    glBindTexture(GL_TEXTURE_2D,texName);

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,checkImageWidth,checkImageHeight,0,GL_RGBA,GL_UNSIGNED_BYTE,checkImage);
}

void display(void){
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    glEnable(GL_TEXTURE_2D);
    glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
    glBindTexture(GL_TEXTURE_2D,texName);
    glBegin(GL_QUADS);
        glTexCoord2f(0.0,0.0);
        glVertex3f(-2.0,-1.0,0.0);
        glTexCoord2f(0.0,1.0);
        glVertex3f(-2.0,1.0,0.0);
        glTexCoord2f(1.0,1.0);
        glVertex3f(0.0,1.0,0.0);
        glTexCoord2f(1.0,0.0);
        glVertex3f(0.0,-1.0,0.0);

        glTexCoord2f(0.0,0.0);
        glVertex3f(1.0,-1.0,0.0);
        glTexCoord2f(0.0,1.0);
        glVertex3f(1.0,1.0,0.0);
        glTexCoord2f(1.0,1.0);
        glVertex3f(2.41421,1.0,-1.41421);
        glTexCoord2f(1.0,0.0);
        glVertex3f(2.41421,-1.0,-1.41421);
    glEnd();
    glFlush();
    glDisable(GL_TEXTURE_2D);
}

void reshape(int w,int h){
    glViewport(0,0,(GLsizei)w,(GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0,(GLfloat)w/(GLfloat)h,1.0,30.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0,0.0,-3.6);
}

int main(int argc,char** argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
    glutInitWindowSize(256,256);
    glutInitWindowPosition(100,100);
    glutCreateWindow(argv[0]);
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}


3.使用求值器进行纹理处理

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

#include <cstdlib>
#include <cstdio>
#include <cmath>

GLfloat ctrlpoints[4][4][3] = {
    {{-1.5,-1.5,4.0},{-0.5,-1.5,2.0},
     {0.5,-1.5,-1.0},{1.5,-1.5,2.0}},
    {{-1.5,-0.5,1.0},{-0.5,-0.5,3.0},
     {0.5,-0.5,0.0},{1.5,-0.5,-1.0}},
    {{-1.5,0.5,4.0},{-0.5,0.5,0.0},
     {0.5,0.5,3.0},{1.5,0.5,4.0}},
    {{-1.5,-1.5,-2.0},{-0.5,1.5,-2.0},
     {0.5,1.5,0.0},{1.5,1.5,-1.0}}
};
GLfloat texpts[2][2][2]={{{0.0,0.0},{0.0,1.0}},{{1.0,0.0},{1.0,1.0}}};

void display(void){
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    glColor3f(1.0,1.0,1.0);
    glEvalMesh2(GL_FILL,0,20,0,20);
    glFlush();
}

#define imageWidth 64
#define imageHeight 64

GLubyte image[3*imageWidth*imageHeight];
void makeImage(void){
    int i,j;
    float ti,tj;

    for(i = 0; i < imageWidth;i++){
        ti = 2.0 * 3.14159265*i/imageWidth;
        for(j = 0; j < imageHeight; j++){
            tj = 2.0 * 3.14169265*j/imageHeight;
            image[3*(imageHeight*i+j)]=(GLubyte)127*(1.0+sin(ti));
            image[3*(imageHeight*i+j)]=(GLubyte)127*(1.0+cos(2*tj));
            image[3*(imageHeight*i+j)+2]=(GLubyte)127*(1.0+cos(ti+tj));
        }
    }
}

void init(void){
    glMap2f(GL_MAP2_VERTEX_3,0,1,3,4,0,1,12,4,&ctrlpoints[0][0][0]);
    glMap2f(GL_MAP2_TEXTURE_COORD_2,0,1,2,2,0,1,4,2,&texpts[0][0][0]);
    glEnable(GL_MAP2_TEXTURE_COORD_2);
    glEnable(GL_MAP2_VERTEX_3);
    glMapGrid2f(20,0.0,1.0,20,0.0,1.0);
    makeImage();
    glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D,0,3,imageWidth,imageHeight,0,GL_RGB,GL_UNSIGNED_BYTE,image);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_FLAT);
}

void reshape(int w,int h){
    glViewport(0,0,(GLsizei)w,(GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if(w <= h)
        glOrtho(-4.0,4.0,-4.0*(GLfloat)h/(GLfloat)w,4.0*(GLfloat)h/(GLfloat)w,-4.0,4.0);
    else
        glOrtho(-4.0*(GLfloat)w/(GLfloat)h,4.0*(GLfloat)w/(GLfloat)h,-4.0,4.0,-4.0,4.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glRotatef(35.0,1.0,1.0,1.0);
}

int main(int argc,char** argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(100,100);
    glutCreateWindow(argv[0]);
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return 0;
}


4.NURBS表面

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

#include <cstdlib>
#include <cstdio>
#include <cmath>

#ifdef CALLBACK
#define CALLBACK
#endif // CALLBACK

GLfloat ctlpoints[4][4][3];
int showPoints = 0;

GLUnurbsObj *theNurb;

void init_surface(void){
    int u,v;
    for(u=0;u<4;u++){
        for(v=0;v<4;v++){
            ctlpoints[u][v][0]=2.0*((GLfloat)u-1.5);
            ctlpoints[u][v][1]=2.0*((GLfloat)v-1.5);
            if((u==1||u==2)&&(v==1||v==2))
                ctlpoints[u][v][2]=3.0;
            else
                ctlpoints[u][v][2]=-3.0;
        }
    }
}

void CALLBACK nurbsError(GLenum errorCode){
    const GLubyte *estring;
    estring = gluErrorString(errorCode);
    fprintf(stderr,"Nurbs Error:%s \n ",estring);
    exit(0);
}

void init(void){
    GLfloat mat_diffuse[] = {0.7,0.7,0.7,1.0};
    GLfloat mat_specular[] = {1.0,1.0,1.0,1.0};
    GLfloat mat_shininess[] = {100.0};

    glClearColor(0.0,0.0,0.0,0.0);
    glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_diffuse);
    glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular);
    glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_AUTO_NORMAL);
    glEnable(GL_NORMALIZE);

    init_surface();
    theNurb = gluNewNurbsRenderer();
    gluNurbsProperty(theNurb,GLU_SAMPLING_TOLERANCE,25.0);
    gluNurbsProperty(theNurb,GLU_DISPLAY_MODE,GLU_FILL);
    gluNurbsCallback(theNurb,GLU_ERROR,(void (__stdcall *)(void))nurbsError);
}

void display(void){
    GLfloat knots[8]={0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0};
    int i,j;

    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    glPushMatrix();
    glRotatef(330.0,1.0,0.0,0.0);
    glScalef(0.5,0.5,0.5);

    gluBeginSurface(theNurb);
    gluNurbsSurface(theNurb,8,knots,8,knots,4*3,8,&ctlpoints[0][0][0],4,4,GL_MAP2_VERTEX_3);
    gluEndSurface(theNurb);

    if(showPoints){
        glPointSize(5.0);
        glDisable(GL_LIGHTING);
        glColor3f(1.0,1.0,0.0);
        glBegin(GL_POINTS);
        for(i=0;i<4;i++){
            for(j=0;j<4;j++){
                glVertex3f(ctlpoints[i][j][0],ctlpoints[i][j][1],ctlpoints[i][j][2]);
            }
        }
        glEnd();
        glEnable(GL_LIGHTING);
    }
    glPopMatrix();
    glFlush();
}

void reshape(int w,int h){
    glViewport(0,0,(GLsizei)w,(GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0,(GLdouble)w/(GLdouble)h,3.0,8.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0,0.0,-5.0);
}

void keyboard(unsigned char key,int x,int y){
    switch(key){
        case 'c':
        case 'C':
            showPoints = !showPoints;
            glutPostRedisplay();
            break;
        case 27:
            exit(0);
            break;
        default:
            break;
    }
}

int main(int argc,char** argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(100,100);
    glutCreateWindow(argv[0]);
    init();
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}


lane_L
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fastlane-utils
02-16
特别是在iOS开发中，`fastlane-utils`作为一个强大的辅助工具，为开发者提供了极大的便利。本文将深入探讨`fastlane-utils`的各个方面，包括其功能、依赖关系以及如何在项目中有效利用。 `fastlane-utils`是专门为...
gluNurbsSurface函数
王孙贵族的专栏
12-08 5491
 NURBS的两种表示通常，一个NURBS曲面F(s,t)包含三个要素：           控制顶点（x,y,z），节点序列(s,t)和权因子(w)，或者说是           带权控制顶点（x*w,y*w,z*w,w）和节点序列(s,t)。OpenGL中提供了对两类曲面的绘制：type=4：GL_MAP2_VERTEX_4 控制顶点带权，每个点记为（x*w,y*w,z*w,w）type=3：
《高效学习OpenGL》 之 GLU的NURBS的接口 gluNewNurbsRenderer(),gluNurbsProperty(),gluNurbsSurface(),gluNurbsCal()
编辑编辑器
03-06 3116
创建一个NURBS对象: GLUnurbs* gluNewNurbsRenderer (void); //创建一个NURBS对象nobj,并返回一个指向这个新对象的指针销毁NURBS对象： void gluDeleteNurbsRenderer(GLUnurbs *nobj); 控制NURBS对象的属性： gluNurbsProperty(theNurb, GLU_S
OpenGL之NURBS曲面构建
phymat.nico的专栏
01-16 1358
一个NURBS曲面F(s,t)包含三个要素： 控制顶点（x,y,z），节点序列(s,t)和权因子(w)， 或者说是 带权控制顶点（x*w,y*w,z*w,w）和节点序列(s,t)。 OpenGL中提供了对两类曲面的绘制： GL_MAP2_VERTEX_4：控制顶点带权，每个点记为（x*w,y*w,z*w,w） GL_MAP2_VERTEX_3：控制...
fastlane-plugin-coveralls
05-03
要开始使用fastlane-plugin-coveralls ，请运行以下命令将其添加到您的项目中： fastlane add_plugin coveralls 关于工作服 将承保范围信息发送给Coveralls 作者注意：在此处添加有关此插件的更详细的描述。 如果...
ONNXRuntime部署Ultra-Fast-Lane-Detection-v2车道线C++和Python源码模型
最新发布
05-02
综上所述，这个项目提供了使用ONNXRuntime部署的Ultra-Fast-Lane-Detection-v2模型，结合C++和Python源码，为开发者提供了深入理解和应用深度学习模型进行车道线检测的实践机会，同时也展示了如何在实际环境中高效地...
lane-detection-master.zip_adas_adas算法_lane_lane-detection_道路检测
07-15
通过深入学习"lane-detection-master"项目，我们可以掌握这些技术细节，不仅有助于理解ADAS工作原理，还能为开发自己的车道检测系统提供基础。该项目的实践性使得开发者可以直接运行代码，观察结果，从而加深理论...
fastlane-plugin-ding_talk_msg_push:发送钉钉机器人消息
05-18
要开始使用fastlane-plugin-ding_talk_msg_push ，请通过运行以下fastlane-plugin-ding_talk_msg_push将其添加到您的项目中： fastlane add_plugin ding_talk_msg_push 关于ding_talk_msg_push dingTalk机器人...
OpenGL实现鼠标绕任意轴旋转/平移/缩放
03-06
自己封装的鼠标封装的鼠标场景漫游工具类RoamingScenceManager，跟界面没有任何关系，压缩包里面有三个工程，分别是Qt，Win32（原生OpenGL界面），MFC 三个环境，里面都用到了RoamingScenceManager，用法简单，适合刚刚学opengl的新手构建场景。
SplineFitting:用于说明 OpenGL 中样条拟合的 C++ 代码
07-10
样条拟合 用于说明 OpenGL 中样条拟合的 C++ 代码 设计一个工具，用户可以使用以下技术以交互方式绘制控制点序列并绘制平滑曲线： (i) 通过在参数空间中计算适当的一阶导数并指定结束条件（通过绘制箭头来显示导数方向），以获得通过这些点中的每一个的分段平滑二阶连续曲线， (ii) 通过这些控制点使用三次 B 样条和 Beta 样条（以适当的参数作为输入）， (iii) 通过绘制具有 (n+1) 个控制点的 n 阶贝塞尔曲线。 该工具还应具有以下功能： (i) 交互式拖动控制点，导致曲线形状发生变化。 当得到所需的形状时，应与参数等一起保存。 (ii) 该工具可以同时处理不同组或组的控制点。 每个组都可以通过以下操作进行编辑： (a) Deletion of a point, (b) Insertion of a new point, and (c) Modi
VC下利用OpenGL构造自由型曲线曲面
Ingenuus的专栏
11-12 3575
摘要：本文介绍了OpenGL在三维物体建模中的应用，并在VC++下通过该技术实现了对自由型曲线曲面的模型搭建。　　关键词：OpenGL；自由型曲线曲面；NURBS；Visual C++ 　　引言　 　随着计算机技术的飞速发展，计算机的性价比越来越高，为计算机图形学的发展奠定了坚实的基础。科学计算可视化、计算机动画和虚拟现实等技术在工程应用中 得到了广泛的使用，这些技术的实现离不开对真实物体的三维建
OpenGL--贝塞尔曲线或曲面
热门推荐
疯狂的程序员
04-29 1万+
理论基础 贝塞尔曲线和曲面：OpenGL只能直接绘制基本图元，对于曲线和曲面我们一般采用一系列线段或多边形来模拟的，这样当线段或多边形增多时必定很耗性能。其实对于这种曲线和曲面，我们可以使用一些控制点，通过求值器程序先计算出坐标等信息，然后直接用这些数据绘制，这样不仅节省内存，还提高了模拟曲线或曲面的精度(本质还是通过线段或多边形绘制的，只是求值器提前算出了曲线或曲面的顶点信息)。 求值器使用一
7.5.5编程实例－Bezier曲线曲面绘制
图形学与可视化
04-17 4373
（a）Bezier曲线                         (b) Bezier曲面 1. 绘制Bezier曲线 #include GLfloat ctrlpoints[4][3] = {{ -4.0, -4.0, 0.0}, { -2.0, 3.0, 0.0}, {2.0, 4.5, 0.0}, {3.0, -3.0, 0.0}}; void init(void) { glCle
计算机图形学头歌实训平台——纹理映射
weixin_51329675的博客
01-05 1016
计算机图形学头歌实训平台——纹理映射
OpenGL曲线、曲面矢量绘制
asiya的博客
05-31 3078
1：用四个控制点绘制一条三次Bezier曲线 Github地址 #include "stdafx.h" #include <stdlib.h> #include <time.h> #include <GL/glut.h> //4个控制点的3D坐标——z坐标全为0 GLfloat ctrlpoints[4][3] = { { -4, -4, 0 }...
OpenGL学习笔记（四）：曲线曲面
雨润的技术博客
06-13 4925
作者：yurunsun@gmail.com 新浪微博@孙雨润 新浪博客 CSDN博客 日期： 2013-6-13 <!-- body {font-size:14px; line-height:1.6; color:#333333; font:13px/1.4 Helvetica,arial,freesans,clean,sans-serif} body > *:
OpenGL 期末考试作业
编程资料大全
08-13 802
1、OpenGL中能渲染的基本元素是什么？(曲面) 答：OPENGL基本元素： GL_POINTS GL_LINES GL_POLYGON GL_LINE_STRIP GL_LINE_LOOP GL_TRANGLES GL_TRANGLE_STRIP 　GL_TRANGLE_FAN GL_QUADS GL_QUAD_STRIP GLU基本元素:NUBRS曲线曲面,二次曲面等 2、常见的渲...
lanenet-lane-detection-master
09-03
总之，lanenet-lane-detection-master 是一个功能强大的车道检测项目，通过深度学习技术实现对道路车道的准确检测。它为自动驾驶和智能交通系统提供了重要的视觉支持，并具有一定的实用性和可扩展性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值