1.坐标法移动

实现原理:取其中的一个顶点作为参考,当我们操作键盘特殊的key时,触发图形的移动,改变参考点的坐标,并相应的改变其他点的坐标

准备工作

与绘制三角形一样,初始化glut,注册监听,设置窗口,当然因为我们要移动图形,所以我们还需要注册一个监听键盘的特殊函数 SpecialKeys是我们自定义的函数名

//注册特殊函数
   glutSpecialFunc(SpecialKeys);

在使用批次的类的时候,使用的GL_TRIANGLE_FAN的顶点连接方式,具体的一些连接方式看这篇文章:OpenGL渲染流程,基本着色器与图元连接方式

$\color{red}{核心代码:}$

void SpecialKeys(int key, int x, int y){
    // stepSize 每次移动的距离
    GLfloat stepSize = 0.025f;
    // 取第一个顶点的x与y作为参考点
    GLfloat blockX = vVerts[0];
    GLfloat blockY = vVerts[1];
    
    printf("v[0] = %f\n",blockX);
    printf("v[10] = %f\n",blockY);

    if (key == GLUT_KEY_UP) {
        // 上
        blockY += stepSize;
    }
    
    if (key == GLUT_KEY_DOWN) {
        // 下
        blockY -= stepSize;
    }
    
    if (key == GLUT_KEY_LEFT) {
    // 左
        blockX -= stepSize;
    }
    
    if (key == GLUT_KEY_RIGHT) {
    // 右
        blockX += stepSize;
    }

    //触碰到边界（4个边界）的处理,如果不处理,图形会超出边界
    //当正方形移动超过最左边的时候
    if (blockX < -1.0f) {
        blockX = -1.0f;
    }
    
    //当正方形移动到最右边时
    //1.0 - blockSize * 2 = 总边长 - 正方形的边长 = 最左边点的位置
    if (blockX > (1.0 - blockSize * 2)) {
        blockX = 1.0f - blockSize * 2;
    }
    
    //当正方形移动到最下面时
    //-1.0 - blockSize * 2 = Y（负轴边界） - 正方形边长 = 最下面点的位置
    if (blockY < -1.0f + blockSize * 2 ) {
        
        blockY = -1.0f + blockSize * 2;
    }
    
    //当正方形移动到最上面时
    if (blockY > 1.0f) {
        
        blockY = 1.0f;
        
    }

    printf("blockX = %f\n",blockX);
    printf("blockY = %f\n",blockY);
    
    
    // 左上顶点
   vVerts[0] = blockX;
       vVerts[1] = blockY;
       printf("(%f,%f)\n",vVerts[0],vVerts[1]);
       // 右上顶点
       vVerts[3] = blockX + blockSize*2;
       vVerts[4] = blockY;
       printf("(%f,%f)\n",vVerts[3],vVerts[4]);
       // 右下顶点
       vVerts[6] =  blockX + blockSize*2;
       vVerts[7] = blockY - blockSize*2;
       printf("(%f,%f)\n",vVerts[6],vVerts[7]);
       // 左下顶点
       vVerts[9] = blockX;
       vVerts[10] = blockY - blockSize*2;
       printf("(%f,%f)\n",vVerts[9],vVerts[10]);
    
    // 将修改后的批次顶点重新复制到批次类里
    triangleBatch.CopyVertexData3f(vVerts);
   // 提交重绘
    glutPostRedisplay();
}

完整代码

#include <stdio.h>
#include "GLTools.h"
#include <glut/glut.h>
//定义一个，着色管理器
GLShaderManager shaderManager;

//简单的批次容器，是GLTools的一个简单的容器类。
GLBatch triangleBatch;
GLfloat blockSize = 0.3f;
GLfloat vVerts[] = {
    -blockSize,blockSize,0,
    blockSize,blockSize,0,
    blockSize,-blockSize,0,
    -blockSize,-blockSize,0,
};

// 改变窗口大小
void changeSize(int w,int h){
    glViewport(0, 0, w, h);
}

void RenderScene(void){
    // 清理buff
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    // 设置画笔
    GLfloat vColor[] = {0,0,0,1};
    shaderManager.UseStockShader(GLT_SHADER_IDENTITY,vColor);
    triangleBatch.Draw();
    glutSwapBuffers();
}

void SpecialKeys(int key, int x, int y){
    printf("%d",key);
    GLfloat stepSize = 0.1f;
    // 取左上角的顶点做为参考点
    GLfloat blockX = vVerts[0];
    GLfloat blockY = vVerts[1];
    if (key == GLUT_KEY_UP) {
       blockY  += stepSize;
    }
    if (key == GLUT_KEY_DOWN) {
       blockY  -= stepSize;
    }
    
    if (key == GLUT_KEY_LEFT) {
         blockX  -= stepSize;
    }
    
    if (key == GLUT_KEY_RIGHT) {
         blockX  += stepSize;
    }
    
     //当正方形移动超过最左边的时候
       if (blockX < -1.0f) {
           blockX = -1.0f;
       }
       
       //当正方形移动到最右边时
       //1.0 - blockSize * 2 = 总边长 - 正方形的边长 = 最左边点的位置
       if (blockX > (1.0 - blockSize * 2)) {
           blockX = 1.0f - blockSize * 2;
       }
       
       //当正方形移动到最下面时
       //-1.0 - blockSize * 2 = Y（负轴边界） - 正方形边长 = 最下面点的位置
       if (blockY < -1.0f + blockSize * 2 ) {
           
           blockY = -1.0f + blockSize * 2;
       }
       
       //当正方形移动到最上面时
       if (blockY > 1.0f) {
           
           blockY = 1.0f;
           
       }
    
       vVerts[0] = blockX;
       vVerts[1] = blockY;
       printf("(%f,%f)\n",vVerts[0],vVerts[1]);
       
       vVerts[3] = blockX + blockSize*2;
       vVerts[4] = blockY;
       printf("(%f,%f)\n",vVerts[3],vVerts[4]);
       
       vVerts[6] =  blockX + blockSize*2;
       vVerts[7] = blockY - blockSize*2;
       printf("(%f,%f)\n",vVerts[6],vVerts[7]);
       
       vVerts[9] = blockX;
       vVerts[10] = blockY - blockSize*2;
       printf("(%f,%f)\n",vVerts[9],vVerts[10]);
    triangleBatch.CopyVertexData3f(vVerts);
    glutPostRedisplay();
    
}

void setupRC(void){
    glClearColor(1, 1, 1, 1);
    shaderManager.InitializeStockShaders();
    
    triangleBatch.Begin(GL_TRIANGLE_FAN, 4);
    triangleBatch.CopyVertexData3f(vVerts);
    triangleBatch.End();
}

int main(int argc,char* argv[])
{
    
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);
    glutInitWindowSize(500, 500);
    glutCreateWindow("坐标移动");
    
    glutReshapeFunc(changeSize);
    glutDisplayFunc(RenderScene);
    glutSpecialFunc(SpecialKeys);
    GLenum status = glewInit();
    if (GLEW_OK != status) {
        
        printf("GLEW Error:%s\n",glewGetErrorString(status));
        return 1;
        
    }
    setupRC();
    glutMainLoop();
    
    return 0;
}

矩阵法移动

如果对于简单的图形,顶点相对较少,我们还可以使用坐标法处理,如果不规则图片,顶点有很多个,且形状不确定,使用坐标法明显不能满足,所以就要使用矩阵法
我们可以理解是这个图形在坐标系上原点的移动

定义记录x与y变化量

GLfloat xPos = 0.0f;
GLfloat yPos = 0.0f;

在SpecialKeys中我们只要记录 xPos与yPos的变化,不在关注每个顶点的坐标变化

if (key == GLUT_KEY_UP) {        
        yPos += stepSize;
    }
    
    if (key == GLUT_KEY_DOWN) {
        yPos -= stepSize;
    }
    
    if (key == GLUT_KEY_LEFT) {
        xPos -= stepSize;
    }
    
    if (key == GLUT_KEY_RIGHT) {
        xPos += stepSize;
    }

相应的改变的是我们在绘制的时候,我要使用矩阵
定义三个矩阵:
mFinalTransform 最终的矩阵
mTransfromMatrix 平移矩阵
mRotationMartix 旋转矩阵

M3DMatrix44f mFinalTransform,mTransfromMatrix,mRotationMartix;

给值平移矩阵方法 xyz代表三个轴改变的值

inline void m3dTranslationMatrix44(M3DMatrix44f m, float x, float y, float z)

给值旋转矩阵方法 angle 角度 xyz代表围绕什么轴旋转,都为0时不旋转

void m3dRotationMatrix44(M3DMatrix44f m, float angle, float x, float y, float z);

将旋转和移动的矩阵结果合并到mFinalTransform （矩阵相乘）

m3dMatrixMultiply44(mFinalTransform, mTransfromMatrix, mRotationMartix);

此时单元着色器不能满足,要使用平面着色器

shaderManager.UseStockShader(GLT_SHADER_IDENTITY,mFinalTransform,vRed);

完整代码:

#include <stdio.h>
#include "GLTools.h"
#include <glut/glut.h>
//定义一个，着色管理器
GLShaderManager shaderManager;

//简单的批次容器，是GLTools的一个简单的容器类。
GLBatch triangleBatch;


//blockSize 边长
GLfloat blockSize = 0.1f;

//正方形的4个点坐标
GLfloat vVerts[] = {
        -blockSize,-blockSize,0.0f,
        blockSize,-blockSize,0.0f,
        blockSize,blockSize,0.0f,
        -blockSize,blockSize,0.0f
};

GLfloat xPos = 0.0f;
GLfloat yPos = 0.0f;


// 改变窗口大小
void changeSize(int w,int h){
    glViewport(0, 0, w, h);
}

void RenderScene(void){
    // 清理buff
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    // 设置画笔
    GLfloat vColor[] = {0,0,0,1};
     M3DMatrix44f mFinalTransform,mTransfromMatrix,mRotationMartix;
      
      //平移
      m3dTranslationMatrix44(mTransfromMatrix, xPos, yPos, 0.0f);
      
      //每次平移时，旋转5度
      static float yRot = 0.0f;
      yRot += 5.0f;
      m3dRotationMatrix44(mRotationMartix, m3dDegToRad(yRot), 0.0f, 0.0f, 1.0f);
      
      //将旋转和移动的矩阵结果 合并到mFinalTransform （矩阵相乘）
      m3dMatrixMultiply44(mFinalTransform, mTransfromMatrix, mRotationMartix);
      
      //将矩阵结果 提交给固定着色器（平面着色器）中绘制
      shaderManager.UseStockShader(GLT_SHADER_FLAT,mFinalTransform,vColor);
      triangleBatch.Draw();
     glutSwapBuffers();
}

void SpecialKeys(int key, int x, int y){
    printf("%d",key);
    GLfloat stepSize = 0.1f;
       if (key == GLUT_KEY_UP) {
           // 上
           yPos += stepSize;
       }
       
       if (key == GLUT_KEY_DOWN) {
           // 下
           yPos -= stepSize;
       }
       
       if (key == GLUT_KEY_LEFT) {
           // 左
           xPos -= stepSize;
       }
       
       if (key == GLUT_KEY_RIGHT) {
           // 左
           xPos += stepSize;
       }
       
       //碰撞检测 当成原点处理
       if (xPos < (-1.0f + blockSize)) {
           
           xPos = -1.0f + blockSize;
       }
       
       if (xPos > (1.0f - blockSize)) {
           xPos = 1.0f - blockSize;
       }
       
       if (yPos < (-1.0f + blockSize)) {
           yPos = -1.0f + blockSize;
       }
       
       if (yPos > (1.0f - blockSize)) {
           yPos = 1.0f - blockSize;
       }
       //重新提交
    glutPostRedisplay();
    
}

void setupRC(void){
    glClearColor(1, 1, 1, 1);
    shaderManager.InitializeStockShaders();
    
    triangleBatch.Begin(GL_TRIANGLE_FAN, 4);
    triangleBatch.CopyVertexData3f(vVerts);
    triangleBatch.End();
}

int main(int argc,char* argv[])
{
    
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);
    glutInitWindowSize(500, 500);
    glutCreateWindow("矩阵移动");
    
    glutReshapeFunc(changeSize);
    glutDisplayFunc(RenderScene);
    glutSpecialFunc(SpecialKeys);
    GLenum status = glewInit();
    if (GLEW_OK != status) {
        
        printf("GLEW Error:%s\n",glewGetErrorString(status));
        return 1;
        
    }
    setupRC();
    glutMainLoop();
    
    return 0;
}

通过键盘控制图形移动(坐标法与矩阵法)