OpenglRobot

最新推荐文章于 2022-11-16 17:05:58 发布
最新推荐文章于 2022-11-16 17:05:58 发布
阅读量592 收藏 1
点赞数 1
分类专栏： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pang241/article/details/51152983
版权

OpenglRobot

该项目使用opengl做的一个机器人，能够行走，旋转，并对机器人贴了图。具体源码请参考我的github

实验环境：visual studio 2015

源码解析

    // gl_robot2.cpp : 定义控制台应用程序的入口点。
    //

    #define GLUT_DISABLE_ATEXIT_HACK
    #pragma comment(lib, "legacy_stdio_definitions.lib")
    #include <windows.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <gl/glut.h>
    #include <gl\GLAUX.H>
    #include <cmath>
    #define GLOBAL_SIZE 0.5
    #define PI 3.1415926
    bool isLeft = true;
    static const GLfloat leg_x = 2.0, leg_y = 0.6, leg_z = 0.5; //腿的坐标系缩放比例
    static const GLfloat body_x = 1.2, body_y = 2.4, body_z = 1.8; //身体的坐标系缩放比例
    static const GLfloat head_x = 1.0, head_z = 1.2, head_y = 1; //头的半径
    static const GLfloat arm_x = 1.6, arm_y = 0.6, arm_z = 0.4; //手臂的坐标系缩放比例
    static const GLfloat head_radis = 0.25;
    static const GLfloat foot_x = 1.0, foot_y = 0.3, foot_z = 0.4; //脚的坐标系缩放比例
    static const GLfloat neck_x = head_x / 2, neck_y = head_y, neck_z = head_z / 4;
    static GLfloat centerX = 0.0, centerY = 0.0, centerZ = 0.0;
    static GLint angle = 0;
    //初始的角度为竖直的
    static int leftHigherLegAngle = -90, rightHigherLegAngle = -90;
    static int LeftLowerLegAngle = 90, rightLowerLegAngle = 0;
    static int leftHigherHandAngle = -90, rightHigherHandAngle = -90;
    static int leftLowerHandAngle = 0, rightLowerHandAngle = 0;
    static int leftFootAngle = 0, rightFootAngle = 0;
    int speed = 1;
    GLUquadricObj *quadratic; //画三维物体时用到
    GLuint g_texture = 0, g_texture_head = 0, g_texture_ground = 0, g_texture_sky = 0;
    void init(void) {
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glShadeModel(GL_FLAT);
        glEnable(GL_DEPTH_TEST);

        //glCullFace(GL_BACK);//背面裁剪(背面不可见)
        //glEnable(GL_CULL_FACE);//启用裁剪
        glEnable(GL_TEXTURE_2D);

        quadratic = gluNewQuadric();
        gluQuadricNormals(quadratic, GLU_SMOOTH);


    }
    //画立方体的函数

    void drawCube_head(GLfloat x, GLfloat y, GLfloat z)
    {
        GLfloat x1 = 0.5 * x / 2;
        GLfloat y1 = 0.5 * y / 2;
        GLfloat z1 = 0.5 * z / 2;
        glBindTexture(GL_TEXTURE_2D, g_texture_head);
        glBegin(GL_QUADS);
        //glPushMatrix();
        //画前面                               
        glVertex3f(-x1, y1, z1);
        glVertex3f(x1, y1, z1);

        glVertex3f(x1, -y1, z1);
        glVertex3f(-x1, -y1, z1);
        //画后面
        glVertex3f(-x1, y1, -z1);
        glVertex3f(x1, y1, -z1);
        glVertex3f(x1, -y1, -z1);
        glVertex3f(-x1, -y1, -z1);
        //画上面
        glVertex3f(-x1, y1, z1);
        glVertex3f(x1, y1, z1);
        glVertex3f(x1, y1, -z1);
        glVertex3f(-x1, y1, -z1);
        //画底面
        glVertex3f(-x1, -y1, z1);
        glVertex3f(x1, -y1, z1);
        glVertex3f(x1, -y1, -z1);
        glVertex3f(-x1, -y1, -z1);
        //画左面
        glTexCoord2f(0.0f, 1.0f);  glVertex3f(-x1, y1, z1);
        glTexCoord2f(1.0f, 1.0f);  glVertex3f(-x1, y1, -z1);
        glTexCoord2f(1.0f, 0.0f);  glVertex3f(-x1, -y1, -z1);
        glTexCoord2f(0.0f, 0.0f);  glVertex3f(-x1, -y1, z1);
        //画右面
        glVertex3f(x1, y1, z1);
        glVertex3f(x1, y1, -z1);
        glVertex3f(x1, -y1, -z1);
        glVertex3f(x1, -y1, z1);
        glEnd();

        //glPopMatrix();
    }
    void drawCube(GLfloat x, GLfloat y, GLfloat z)
    {

        GLfloat x1 = 0.5 * x / 2;
        GLfloat y1 = 0.5 * y / 2;
        GLfloat z1 = 0.5 * z / 2;
        glBindTexture(GL_TEXTURE_2D, g_texture);
        glBegin(GL_QUADS);
        //glPushMatrix();
        //画前面                               
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-x1, y1, z1);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(x1, y1, z1);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(x1, -y1, z1);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-x1, -y1, z1);
        //画后面
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-x1, y1, -z1);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(x1, y1, -z1);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(x1, -y1, -z1);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-x1, -y1, -z1);
        //画上面
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-x1, y1, z1);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(x1, y1, z1);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(x1, y1, -z1);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-x1, y1, -z1);
        //画底面
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-x1, -y1, z1);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(x1, -y1, z1);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(x1, -y1, -z1);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-x1, -y1, -z1);
        //画左面
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-x1, y1, z1);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(-x1, y1, -z1);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(-x1, -y1, -z1);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-x1, -y1, z1);
        //画右面
        glTexCoord2f(0.0f, 0.0f); glVertex3f(x1, y1, z1);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(x1, y1, -z1);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(x1, -y1, -z1);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(x1, -y1, z1);
        glEnd();

        //glPopMatrix();
    }
    int LoadGLTexTures_head(GLuint& unTexture, const char* chFileName)
    {
        AUX_RGBImageRec *TextureImage; //保存贴图数据的指针
        TextureImage = auxDIBImageLoadA((LPCSTR)"face.bmp");
        //TextureImage_head = auxDIBImageLoadA((LPCSTR)"face.bmp");
        glGenTextures(1, &unTexture);
        glBindTexture(GL_TEXTURE_2D, unTexture);
        //设置纹理的信息，
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage->sizeX, TextureImage->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage->data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //设置滤波为线性滤波
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//线性滤波

        if (TextureImage)//释放资源
        {
            if (TextureImage->data)
            {
                free(TextureImage->data);
            }
            free(TextureImage);
        }
        return 1;
    }

    int LoadGLTexTures(GLuint& unTexture, const char* chFileName)
    {
        AUX_RGBImageRec *TextureImage; //保存贴图数据的指针
        TextureImage = auxDIBImageLoadA((LPCSTR)"body.bmp");
        //TextureImage_head = auxDIBImageLoadA((LPCSTR)"face.bmp");
        glGenTextures(1, &unTexture);
        glBindTexture(GL_TEXTURE_2D, unTexture);
        //设置纹理的信息，
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage->sizeX, TextureImage->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage->data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //设置滤波为线性滤波
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//线性滤波

        if (TextureImage)//释放资源
        {
            if (TextureImage->data)
            {
                free(TextureImage->data);
            }
            free(TextureImage);
        }
        return 1;
    }
    int LoadGLTexTures_ground(GLuint& unTexture, const char* chFileName)
    {
        AUX_RGBImageRec *TextureImage; //保存贴图数据的指针
        TextureImage = auxDIBImageLoadA((LPCSTR)"ground.bmp");
        //TextureImage_head = auxDIBImageLoadA((LPCSTR)"face.bmp");
        glGenTextures(1, &unTexture);
        glBindTexture(GL_TEXTURE_2D, unTexture);
        //设置纹理的信息，
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage->sizeX, TextureImage->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage->data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //设置滤波为线性滤波
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//线性滤波

        if (TextureImage)//释放资源
        {
            if (TextureImage->data)
            {
                free(TextureImage->data);
            }
            free(TextureImage);
        }
        return 1;
    }
    int LoadGLTexTures_sky(GLuint& unTexture, const char* chFileName)
    {
        AUX_RGBImageRec *TextureImage; //保存贴图数据的指针
        TextureImage = auxDIBImageLoadA((LPCSTR)"sky.bmp");
        //TextureImage_head = auxDIBImageLoadA((LPCSTR)"face.bmp");
        glGenTextures(1, &unTexture);
        glBindTexture(GL_TEXTURE_2D, unTexture);
        //设置纹理的信息，
        glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage->sizeX, TextureImage->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage->data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //设置滤波为线性滤波
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//线性滤波

        if (TextureImage)//释放资源
        {
            if (TextureImage->data)
            {
                free(TextureImage->data);
            }
            free(TextureImage);
        }
        return 1;
    }
    void DrawGround()
    {
        GLfloat y = -GLOBAL_SIZE * leg_x * 2 - GLOBAL_SIZE * foot_y;
        glBindTexture(GL_TEXTURE_2D, g_texture_ground);
        glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ - 20.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ + 20.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(centerX + 20.0f, y, centerZ + 20.0f);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(centerX + 20.0f, y, centerZ - 20.0f);
        glEnd();
    }
    void DrawSky()
    {
        GLfloat y = 3.5;
        GLfloat y1 = -GLOBAL_SIZE * leg_x * 2 - GLOBAL_SIZE * foot_y;
        glBindTexture(GL_TEXTURE_2D, g_texture_sky);
        glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ - 20.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ + 20.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(centerX + 20.0f, y, centerZ + 20.0f);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(centerX + 20.0f, y, centerZ - 20.0f);

        glTexCoord2f(0.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ - 20.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ + 20.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(centerX - 20.0f, y1, centerZ + 20.0f);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(centerX - 20.0f, y1, centerZ - 20.0f);

        glTexCoord2f(0.0f, 1.0f); glVertex3f(centerX + 20.0f, y, centerZ - 20.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(centerX + 20.0f, y, centerZ + 20.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(centerX + 20.0f, y1, centerZ + 20.0f);
        glTexCoord2f(0.0f, 0.0f); glVertex3f(centerX + 20.0f, y1, centerZ - 20.0f);

        glTexCoord2f(0.0f, 0.0f); glVertex3f(centerX - 20.0f, y, centerZ - 20.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(centerX + 20.0f, y, centerZ - 20.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(centerX + 20.0f, y1, centerZ - 20.0f);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(centerX - 20.0f, y1, centerZ - 20.0f);
        glEnd();
    }
    void display(void) {

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清空颜色缓冲和深度缓冲
        DrawGround();
        DrawSky();
        glColor3f(0.8, 0.8, 0.8);

        glPushMatrix(); //robot的位置和方向设置
        glTranslatef(centerX, centerY, centerZ);
        glRotatef(angle, 0.0, 1.0, 0.0);
        glColor3f(0.5, 0.5, 0.5); //设置颜色为灰色

        glPushMatrix();  //画出左大腿
        glColor3f(0.5, 0.5, 0.5);
        glRotatef((GLfloat)leftHigherLegAngle, 0, 0, 1.0);
        glTranslatef(0.5*leg_x / 2, 0.0, leg_z * 0.5);
        glPushMatrix();
        glScalef(leg_x, leg_y, leg_z);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glTranslatef(0.5 * leg_x / 2, 0.0, 0.0); //画关节
        glPushMatrix();
        glTranslatef(0.0, 0.0, -0.5*leg_z / 2);
        gluCylinder(quadratic, 0.5 * leg_y / 2, 0.5 * leg_y / 2, leg_z * 0.5, 32, 32);
        glPopMatrix();
        glRotatef(LeftLowerLegAngle, 0.0, 0.0, 1.0); //画左小腿
        glTranslatef(0.5*leg_x / 2, 0.0, 0.0);
        glPushMatrix();
        glColor3f(0.5, 0.5, 0.5);
        glScalef(leg_x - 0.2, leg_y - 0.2, leg_z - 0.2);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glTranslatef(0.5*leg_x / 2, 0.0, 0.0);
        glRotatef(90, 0.0, 0.0, 1.0);
        glTranslatef(-0.5*foot_x / 2 + 0.5*foot_y / 2, 0.0, 0.0);
        glRotatef(leftFootAngle, 0.0, 0.0, 1.0);
        glPushMatrix();
        glScalef(foot_x, foot_y, foot_z);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glPopMatrix();

        glPushMatrix();  //画出右大腿
        glColor3f(0.25, 0.45, 0.25);
        glRotatef((GLfloat)rightHigherLegAngle, 0, 0, 1.0);
        glTranslatef(leg_x / 4, 0.0, -leg_z / 2);
        glPushMatrix();
        glScalef(leg_x, leg_y, leg_z);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glTranslatef(leg_x / 4, 0, 0); //画关节
        glPushMatrix();
        glTranslatef(0.0, 0.0, -leg_z / 4);
        gluCylinder(quadratic, leg_y / 4, leg_y / 4, leg_z / 2, 32, 32);
        glPopMatrix();
        glRotatef(rightLowerLegAngle, 0.0, 0.0, 1.0); //画左小腿
        glTranslatef(leg_x / 4, 0.0, 0.0);
        glPushMatrix();
        glColor3f(0.5, 0.5, 0.5);
        glScalef(leg_x - 0.2, leg_y - 0.2, leg_z - 0.2);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glTranslatef(leg_x / 4, 0.0, 0.0);
        glRotatef(90, 0.0, 0.0, 1.0);
        glTranslatef(-foot_x / 4 + leg_y / 4, 0.0, 0.0);
        glRotatef(rightFootAngle, 0.0, 0.0, 1.0);
        glPushMatrix();
        glScalef(foot_x, foot_y, foot_z);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glPopMatrix();

        // 身体
        glColor3f(1.0, 1.0, 1.0);
        glPushMatrix();
        glColor3f(0.65, 0.45, 0.45);
        glTranslatef(0, body_y / 4, 0.0);
        drawCube(body_x, body_y, body_z);
        glPopMatrix();

        glPushMatrix(); //脖子
        glColor3f(0.25, 0.75, 0.75);
        glTranslatef(0, 0.5*body_y, 0);
        glScalef(neck_x, neck_y, neck_z);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();

        // 头部
        glPushMatrix();
        glColor3f(0.5, 0.5, 0.5);
        glTranslatef(0, 0.5*body_y + 0.5*head_y, 0);
        drawCube_head(head_x, head_y, head_z);
        glPopMatrix();

        glColor3f(0.5, 0.55, 0.55);
        glPushMatrix(); //画左手
        glColor3f(0.5, 0.6, 0.6);
        glTranslatef(0, 0.5*body_y, 0.0);
        glRotatef(leftHigherHandAngle, 0.0, 0.0, 1.0);
        glTranslatef(arm_x / 4, 0.0, (body_z + arm_z) / 4);
        glPushMatrix();
        glScalef(arm_x - 0.1, arm_y - 0.1, arm_z - 0.1);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glTranslatef(arm_x / 4, 0.0, 0.0);
        glPushMatrix();
        glColor3f(0.5, 0.55, 0.55);
        glTranslatef(0.0, 0.0, -arm_z / 4);
        gluCylinder(quadratic, arm_y / 4, arm_y / 4, arm_z*0.5, 32, 32);
        glPopMatrix();

        glRotatef(leftLowerHandAngle, 0.0, 0.0, 1.0);
        glTranslatef(arm_x / 4, 0.0, 0.0);
        glPushMatrix();
        glScalef(arm_x - 0.1, arm_y - 0.1, arm_z - 0.1);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glPopMatrix();

        glPushMatrix(); //画右手
        glColor3f(0.5, 0.55, 0.55);
        glTranslatef(0, body_y / 2, 0.0);
        glRotatef(rightHigherHandAngle, 0.0, 0.0, 1.0);
        glTranslatef(arm_x / 4, 0.0, -(body_z + arm_z) / 4);
        glPushMatrix();
        glScalef(arm_x, arm_y, arm_z);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glTranslatef(arm_x / 4, 0.0, 0.0);
        glPushMatrix();
        glColor3f(0.5, 0.55, 0.55);
        glTranslatef(0.0, 0.0, -arm_z / 4);
        gluCylinder(quadratic, arm_y / 4, arm_y / 4, arm_z*0.5, 32, 32);
        glPopMatrix();

        glRotatef(rightLowerHandAngle, 0.0, 0.0, 1.0);
        glTranslatef(arm_x / 4, 0.0, 0.0);
        glPushMatrix();
        glScalef(arm_x - 0.1, arm_y - 0.1, arm_z - 0.1);
        glutSolidCube(GLOBAL_SIZE);
        glPopMatrix();
        glPopMatrix();
        glPopMatrix();
        glFlush();
        glutSwapBuffers();
    }

    static double lookatx = -3.5, lookatz = -3.5, lookaty = 0;
    static int scrw, scrh;
    //实时刷新
    void reshape(int w, int h) {
        scrw = w;
        scrh = h;
        glViewport(0, 0, (GLsizei)w, (GLsizei)h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(60.0, (GLfloat)w / (GLfloat)h, 1.0, 200.0);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(lookatx, lookaty, lookatz, centerX, 0, centerZ, 0.0, 1.0, 0.0);
    }

    //响应鼠标事件
    void passiveMotionFunc(int x, int y) {
        lookatx = -5.0 + (double)x / scrw * 10.0;
        lookatz = sqrt(25 - lookatx * lookatx) + centerZ;
        lookatx += centerX;
        double tmpy = -5.0 + (double)y / scrh * 10.0;
        if (tmpy >= -GLOBAL_SIZE * leg_x * 2)
            lookaty = tmpy;
        glLoadIdentity();
        glutPostRedisplay();
        gluLookAt(lookatx, lookaty, lookatz, centerX, 0, centerZ, 0.0, 1.0, 0.0);
    }

    bool left = false;
    //规定当角度大于-75度时，小腿的角度变化，并比大腿变化快，规定是大腿地4倍
    //响应键盘事件的，当按'w'时先前走，当按's'时为向后转
    void keyboard(unsigned char key, int x, int y)
    {
        switch (key)
        {
        case 'w':

            for (int i = 0; i < speed; i++) {

                centerY = leg_x * sin(-leftHigherLegAngle / 180.0 * PI) - leg_x;
                // 为了简化计算，我粗略假定大腿每动1度，人会朝着其方向前进0.035个单位长度
                double mvx = cos(angle / 180.0 * PI) * 0.035; // 计算x轴方向移动的距离
                double mvz = sin(angle / 180.0 * PI) * 0.035; // 计算z轴方向移动的距离
                if (!left) { //左脚迈出
                    leftHigherLegAngle--;
                    rightHigherLegAngle++;
                    if (leftHigherLegAngle >= -75) {
                        LeftLowerLegAngle += 6;
                        leftFootAngle = 0;
                    }
                    else if (leftHigherLegAngle < -105) LeftLowerLegAngle -= 6;

                    if (leftHigherLegAngle == -120) {
                        left = true;

                    }

                    leftHigherHandAngle++;
                    leftLowerHandAngle++;
                    rightHigherHandAngle--;
                    rightLowerHandAngle--;
                }
                else {
                    leftHigherLegAngle++;
                    rightHigherLegAngle--;
                    if (rightHigherLegAngle >= -75) {
                        rightLowerLegAngle += 6;
                        rightFootAngle = 0;
                    }
                    else if (rightHigherLegAngle < -105) rightLowerLegAngle -= 6;

                    if (leftHigherLegAngle == -60) left = false;

                    leftHigherHandAngle--;
                    leftLowerHandAngle--;
                    rightHigherHandAngle++;
                    rightLowerHandAngle++;
                }
                centerX -= mvx;
                lookatx -= mvx;
                centerZ += mvz;
                lookatz += mvz;

                // 调整视角，始终把屏幕中心对准人的中心
                glLoadIdentity();
                gluLookAt(lookatx, lookaty, lookatz, centerX, 0, centerZ, 0.0, 1.0, 0.0);
                glutPostRedisplay();
            }
            break;
        case 's':
            angle = (angle + 180) % 360;

            glutPostRedisplay();
            break;
        case 'a': //左转
            angle = (angle + 5) % 360;
            glutPostRedisplay();
            break;
        case 'd': //右转
            angle = (angle - 5) % 360;
            glutPostRedisplay();
            break;
        case 'f':
            speed++;
            break;
        case 'h':
            if (speed > 0)
                speed--;
            break;
        }
    }

    //设置光照  
    void SetupLights()
    {
        GLfloat ambientLight[] = { 0.45f,  0.45f,  0.5f,  1.0f };//环境光  
        GLfloat diffuseLight[] = { 0.55f,  0.55f,  0.55f,  1.0f };//漫反射  
        GLfloat specularLight[] = { 0.6f,  0.6f,  0.6f,  1.0f };//镜面光  
        GLfloat lightPos[] = { 50.0f, 80.0f, 60.0f, 1.0f };//光源位置  

        glEnable(GL_LIGHTING);  //启用光照  
        glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);//设置环境光源  
        glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);//设置漫反射光源  
        glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);   //设置镜面光源  
        glLightfv(GL_LIGHT0, GL_POSITION, lightPos);//设置灯光位置  
        glEnable(GL_LIGHT0);//打开第一个灯光  

        glEnable(GL_COLOR_MATERIAL);//启用材质的颜色跟踪  
        glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);  //指定材料着色的面  
        glMaterialfv(GL_FRONT, GL_SPECULAR, specularLight); //指定材料对镜面光的反应  
        glMateriali(GL_FRONT, GL_SHININESS, 100);   //指定反射系数  
    }

    int main(int argc, char **argv) {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
        glutInitWindowSize(500, 500);
        glutInitWindowPosition(100, 100);
        glutCreateWindow(argv[0]);
        init();
        LoadGLTexTures(g_texture, "body.bmp");
        LoadGLTexTures_head(g_texture_head, "face.bmp");
        LoadGLTexTures_ground(g_texture_ground, "ground.bmp");
        LoadGLTexTures_sky(g_texture_sky, "sky.bmp");
        glutDisplayFunc(display);
        glutReshapeFunc(reshape);  //屏幕刷新是用
        glutKeyboardFunc(keyboard);//按下按键
        glutPassiveMotionFunc(passiveMotionFunc);//鼠标转动
        SetupLights();
        glutMainLoop();
        return 0;
    }

实验截图

bin2415
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
openGL+vs2013机器人行走动画
05-05
openGL+vs2013机器人行走动画，机器人的头部、手臂、腿、都可以通过键盘响应事件。
【OpenGL】绘制2D机器人并实现二维变换的综合运用
敲代码两年半的练习生博客
03-24 1613
【OpenGL】绘制2D机器人并实现二维变换的综合运用1.绘制目标2.核心代码2.1 绘制矩形2.2 绘制机器人的躯体2.3 绘制机器人的手臂2.4 绘制机器人的脚2.5 绘制圆面2.6 绘制圆弧2.7 绘制脸蛋2.8 键盘响应2.9 绘制2D机器人3.全部代码4.运行结果 1.绘制目标 绘制2D机器人并实现二维变换的综合运用 2.核心代码 2.1 绘制矩形 void _init() { glClearColor(1.0f, 1.0f, 1.0f, 1.0f); } /// <summary
使用opengl实现一个简易的robot模拟
chenjieb520--两片森林的技术博客
03-03 1万+
作者：chenjieb520 这是我一个很早以前写得关于3D  robot仿真模拟的一个简易实现方式。希望对于学习OPENGL的同学有帮助。 效果图如下： 代码如下： #include    #include     #include     #include    #include   /* 作者：chenjieb520 *1、显示场景，并在指定视线
计算机图形学——OpenGL学习系列会动的机器人
热门推荐
小黄鸭的博客
03-28 1万+
计算机图形学——OpenGl学习系列会动的机器人 应课程要求做了一个简单的机器人，嘻嘻感觉还是萌萌哒，完全新手还有好多地方不足，以后改吧后面设置全屏什么的是借鉴的别人的 至今还没看明白所以没有注释#define WIN32_LEAN_AND_MEAN #include #include #include #pragma comment(lib, "openGL32.lib") #pragm
【OpenGL】光源处理 / 机器人行走动画
三七
05-05 1404
参考文章：OpenGL特殊光处理 OpenGL光照模型： 全局泛光强度 视点位置在景物的位置 物体的正面和背面是否分别进行光照计算 全局环境光： 使用参数 ： GL_LIGHT_MODLE_AMBIENT GLfloat globle_ambient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; //全局环境光 glLightModelfv(GL_L...
OpenGLRobot例子
04-30
OpenGL制作机器人的C++代码
opengl-robot:a robot draw by opengl in c , can walk and light .一个用Opengl实现的简单的机器人
07-03
openglrobot a robot draw by opengl in c , can walk and light .一个用Opengl实现的简单的机器人
Qt+OpenGL进阶教学之三维模型读取
mai0026的博客
11-16 4568
STEP三维模型转OBJ模型在OpenGL中绘制
[Qt + OpenGL]实现机械臂3D显示
俊俊的博客
05-06 1万+
机械臂3d显示 1、通关节角度调整机械臂姿态（关节运动） 2、示教点 3、坐标系显示 4、支持机械臂3d显示 5、支持桌子、xy平台3d显示 6、系统资源监控 6、系统资源监控
GLRobot:网页与webgl的机械臂页面
05-14
机器人 具有webgl技术的网页的机械臂页面 该网站由仿真和设计两部分组成。 在“模拟”部分中，您可以查看最知名的机械臂品牌的不同模型。 在设计部分，用户可以通过在零件目录中选择机械臂的不同零件来设计自己的机械臂。 在这两个选项中，我们可以注册一系列动作，以便可以依次执行这些动作，从而产生运动效果。
OpenGl机器人行走
10-13
OpenGl 机器人可以通过方向键实现自由移动
opengl 实现的机器人行走
08-12
opengl 实现的机器人行走 opengl 实现的机器人行走 opengl 实现的机器人行走
OpenGL机器人
10-13
本程序利用OpenGL和线条绘制出加单的机器人，可以用上下左右键来操控机器人的运动。
OpenGL Robot
11-24
使用openGL实现一个机器人，头部、手、腿部能动，带有光照
opengl绘制的简单机器人 可以实现走路
12-30
用opengl绘制的3D机器人，实现了光照的利用，并且实现了，机器人的走动，旋转。
openGL期末大作业——行走的机器人
11-05
实现机器人带光照的绘制和运动变换。通过glPushMatrix() 和glPopMatrix()绘制出机器人层次结构模型和几何变换，要求实现机器人手、脚、头、肩膀的旋转等几何变换，能够实现机器人走路的效果。同时机器人打上光照。内付完整代码以及实验报告！！
OpenGL+glut实现机器人在简单场景中的运动
05-01
用OpenGL+glut实现简单人物在简单场景中的漫游，所有物体都是用线框表示的，以便于观察，具体介绍和效果图可以到http://blog.sina.com.cn/s/blog_487547aa0100afd4.html看。
OpenGL实现机器人运动（下蹲、起身、走、跑）
07-23
该程序通过OpenGL实现机器人运动（下蹲、起身、走、跑），可以作为学习OpenGL机器人连续运动的一个参考
实现机器人的手臂的旋转 用opengl实现
03-31
很好的机器人例子，是计算机图形学的很好的例子，用opengl实现，vc++ 控制台 ，代码简单实用，好玩，希望大家喜欢哦
node-v10.22.0-darwin-x64.tar.xz
最新发布
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值