下面是一首好听的歌，下文可以边听边看哈。2019年初中区教研会上，区教研员罗老师为我们做了一个生动精彩的讲座——《求最值专题研究》，所举的例子都很有代表性，涉及的动点最值问题难度比较大，我们老师听了感觉收获很多。
之前写了：
阿氏圆中的最大、最小值问题(区教研)
重叠面积的求法和动画制作(区教研系列2)
从费马点问题谈利用旋转构造全等或相似的妙处(区教研系列3)
今天继续对罗老师的例子进行学习。今天探讨的是一个四动点最值的难题。
这样的问题笔者也曾经写过，例如：(点击可打开)
一个双动点最值难题；
初三培优系列8：因动点产生的特殊四边形问题；
双动点运动的图像制作(兼谈对geogebra的热爱)——2018年广东省中考数学压轴题探究
呈现原题：
题意和难点分析：1，点E是线段CD上的主动点，运动中CF和BE垂直保持不变，这里隐含中一个隐形圆，即点F的轨迹是圆的一部分，这一点必须用上；隐形圆可参考笔者所写的文章：初三培优系列5：隐形圆专题1——2019扬州中考为例；2，PF和CF保持不变，这个条件能说明什么？有什么用？3，点M，N这两个也是动点，从而产生的三角形PMN也是会变化的。所以三角形PMN的周长和面积都应该有最值。此题仅仅是求周长的最小值。如果改为求面积的最小值或最大值，又怎么求？解题者脑中要有下面的动态变化，或者在草稿纸中多画一下：
解决：
静态图形如下：
解题反思：1、研究难题的方法可以参考罗增儒教授的“自觉分析”的方法，即经历“整体分解和信息交合”两个操作步骤，具体是：此题的解决主要分为四个步骤，步骤一……请问：此题如何利用自觉分析的方法进行解析？2，罗老师说过，此题他曾经尝试想用解析几何(建系)的方法，但是不好做，真的做不了吗？如果建系的方法做不出来，原因是什么？3，作为教学，如果学生程度高，可以直接摆出这样的题；但如果学生学习水平还比较低，可以采用吴和贵老师提出的“支架教学理论”或谢明初教授提出的“西蒙数学法”，即把问题分解，先让学生解决简单的，容易的，然后逐级而上，……请问，如何设计这种题目的认知工作单？……欢迎在文章后面下面留言哈。
美丽的分形树您可能感兴趣的相关文献：(点击可打开)重叠面积的求法和动画制作(区教研系列2)阿氏圆中的最大、最小值问题(区教研)初二培优系列6：动态与静态的融通——评析2019年五中初二上学期期中数学试题读罗增儒教授的解题：2019年中考数学素养导向的试题观察5——2019年长沙数学中考第26题
动静结合中交替演绎定性分析与定量刻画，2019年中考数学：素养导向的试题观察4——2019广东25题()
2019年中考数学：素养导向的试题观察3——2019南京16题(定弦定角)2019年中考数学：素养导向的试题观察2——2019宿迁27题
2019年中考数学：素养导向的试题观察1——2019连云港16题；
读姚静教授的文章：他们为什么在应用题上失败了
初一培优系列5：绝对值与“奇点偶段”
初二培优系列5：等腰(边)三角形动点论问题和讨
初三培优系列4:帅出新天际(2)？——2018年海珠一模第25题
初三培优系列3:帅出新天际(1)？——2018年海珠一模第25题
初三培优系列2:2018广州中考第24题——不给图的数形结合题；
初三培优系列1：2016广州中考数学压轴题解析；
初一培优系列3：史上最难？2018年区初一上半学期数轴动点问题
(微信中长按可关注)

三角形
github源码仓库
opengl环境准备
opengl编程从入门到精通-hello,window
OpenGL从入门到精通–你好三角形
OpenGL从入门到精通–着色器的使用

绘图中需要牢记下面这几个单词

顶点数组对象：Vertex Array Object, VAO
顶点缓冲对象：Vertex Buffer Object, VBO
索引缓冲区：Element Buffer Object, EBO或Index Buffer Object, IBO


在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。图形渲染管线可以被划分为两个主要部分：第一部分把你的3D坐标转换为2D坐标，第二部分是把2D坐标转变为实际的有颜色的像素。这个教程里，我们会简单地讨论一下图形渲染管线，以及如何利用它创建一些漂亮的像素。


图形渲染管线接受一组3D坐标，然后把它们转变为你屏幕上的有色2D像素输出。图形渲染管线可以被划分为几个阶段，每个阶段将会把前一个阶段的输出作为输入。所有这些阶段都是高度专门化的（它们都有一个特定的函数），并且很容易并行执行。正是由于它们具有并行执行的特性，当今大多数显卡都有成千上万的小处理核心，它们在GPU上为每一个（渲染管线）阶段运行各自的小程序，从而在图形渲染管线中快速处理你的数据。这些小程序叫做着色器(Shader)。


OpenGL着色器是用OpenGL着色器语言(OpenGL Shading Language, GLSL)写成的，在下一节中我们再花更多时间研究它。

顶点的输入
想绘制一个图形，肯定得给出图像的坐标点，这里我们直接给出的坐标点就是标准化之后的坐标点，所以在设置向量属性的时候，设置的也是GL_FALSE不需要再进一步的进行标准化。
顶点信息
float vertices[] = {
    -0.5f, -0.5f, 0.0f, // left
    0.5f, -0.5f, 0.0f, // right
    0.0f,  0.5f, 0.0f  // top
};

设置顶点属性也选择GL_FALSE
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

因为OpenGL想要快速的绘制一张图形，一般都是走的GPU因此这里绘制图形也是要用到GPU关于GPU着色器的介绍可以参考：
OpenGL-你好三角形
下面要做的就是把顶点信息放到缓存中去
unsigned int VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
/* 要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用 */
/* // ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
    // 1. 绑定VAO */
glBindVertexArray(VAO);
// 2. 把顶点数组复制到缓冲中供OpenGL使用
glBindBuffer(GL_ARRAY_BUFFER, VBO);
// 把之前定义的顶点，复制到缓冲的内存中去
/*
    GL_STATIC_DRAW ：数据不会或几乎不会改变。
    GL_DYNAMIC_DRAW：数据会被改变很多。
    GL_STREAM_DRAW ：数据每次绘制时都会改变。 */
/*
    三角形的位置数据不会改变，每次渲染调用时都保持原样，所以它的使用类型最好是GL_STATIC_DRAW。
    如果，比如说一个缓冲中的数据将频繁被改变，那么使用的类型就是GL_DYNAMIC_DRAW或GL_STREAM_DRAW，
    这样就能确保显卡把数据放在能够高速写入的内存部分。 */
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

/*
    位置数据被储存为32位（4字节）浮点值。
    每个位置包含3个这样的值。
    在这3个值之间没有空隙（或其他值）。这几个值在数组中紧密排列(Tightly Packed)。
    数据中第一个值在缓冲开始的位置 */
//  告诉GPU数据怎样取
/*
    第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用layout(location = 0)
       定义了position顶点属性的位置值(Location)吗？它可以把顶点属性的位置值设置为0。
       因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入0。
    第二个参数指定顶点属性的大小。顶点属性是一个vec3，它由3个值组成，所以大小是3。
    第三个参数指定数据的类型，这里是GL_FLOAT(GLSL中vec*都是由浮点数值组成的)。
    下个参数定义我们是否希望数据被标准化(Normalize)。如果我们设置为GL_TRUE，
       所有数据都会被映射到0（对于有符号型signed数据是-1）到1之间。
       我们把它设置为GL_FALSE。
    第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。
      由于下个组位置数据在3个float之后，我们把步长设置为3 * sizeof(float)。
      要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）
      我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。
      一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，
      我们在后面会看到更多的例子（译注: 这个参数的意思简单说
      就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节）。
    最后一个参数的类型是void*，所以需要我们进行这个奇怪的强制类型转换。
      它表示位置数据在缓冲中起始位置的偏移量(Offset)。由于位置数据在数组的开头，
      所以这里是0。我们会在后面详细解释这个参数。 */
//   设置顶点属性指针
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
/*
    现在我们已经定义了OpenGL该如何解释顶点数据，
    我们现在应该使用glEnableVertexAttribArray，
    以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。 */
glEnableVertexAttribArray(0);

// note that this is allowed, the call to glVertexAttribPointer registered 
//VBO as the vertex attribute's bound   vertex buffer object so afterwards we can safely unbind
glBindBuffer(GL_ARRAY_BUFFER, 0);

// You can unbind the VAO afterwards so other VAO calls 
//won't accidentally modify this VAO, but this rarely happens. Modifying other
// VAOs requires a call to glBindVertexArray anyways 
//so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
glBindVertexArray(0);

着色器
着色器创建需要创建顶点着色器和片段着色器，然后使用链接程序把两个着色器链接，需要注意的是链接程序链接的着色器前一个程序的输出，必须要和后面一个程序的输入对应，否则就会报错。

创建着色器

// build and compile our shader program
// ------------------------------------
// vertex shader
// 创建一个着色器对象， 返回出着色器的ID
//  顶点着色器
int vertexShader = glCreateShader(GL_VERTEX_SHADER);

因为着色器是运行在GPU上的一个个小程序，因此需要动态编译，需要时将编译好的程序交给GPU运行，使用的语言是GLSL需要了解的可以看
着色器
const char *vertexShaderSource = "#version 330 core\n"
                                 "layout (location = 0) in vec3 aPos;\n"
                                 "void main()\n"
                                 "{\n"
                                 "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
                                 "}\0";
// 将着色器源码附加到着色器对象上，然后使用glCompileShader进行编译
// param1 着色器ID, param2 源码字符串数量
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

因为传入的是程序片段，我们需要知道程序是运行时出错还是根本就编译不过，可以使用glGetShaderiv函数获取上述程序编译的状态
// check for shader compile errors
int success; // 获取程序编译的状态，0成功非0失败
char infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
    // 程序编译失败的信息
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
    std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
}

用同样的方法处理片段着色器
// fragment shader
// 片段着色器
int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
// check for shader compile errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
    std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
}

使用连接器链接两个着色器
 // link shaders
 /*
 当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。
 当输出和输入不匹配的时候，你会得到一个连接错误。
 */
 int shaderProgram = glCreateProgram();
 glAttachShader(shaderProgram, vertexShader);
 glAttachShader(shaderProgram, fragmentShader);
 glLinkProgram(shaderProgram);
 // check for linking errors
 glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
 if (!success) {
 glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
 std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
 }

在Render里面渲染三角形
// draw our first triangle
// 2. 当我们渲染一个物体时要使用着色器程序
glUseProgram(shaderProgram);
glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
// 3. 绘制物体 GL_TRIANGLES 绘制三角形，从0起点开始绘制，绘制3个点
glDrawArrays(GL_TRIANGLES, 0, 3);

完整代码实现
//
// Created by andrew on 2021/1/17.
//
#include "glad/glad.h"
#include <GLFW/glfw3.h>

#include <iostream>

using namespace std;

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

const char *vertexShaderSource = "#version 330 core\n"
                                 "layout (location = 0) in vec3 aPos;\n"
                                 "void main()\n"
                                 "{\n"
                                 "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
                                 "}\0";
const char *fragmentShaderSource = "#version 330 core\n"
                                   "out vec4 FragColor;\n"
                                   "void main()\n"
                                   "{\n"
                                   "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
                                   "}\n\0";


int main()
{
    // 对glfw进行初始化
    glfwInit();
    // 打印出glfw的版本信息
    //    int* major, int* minor, int* rev
    int major, minor, rev;
    glfwGetVersion(&major, &minor, &rev);
    cout << "major = " << major << " minor = " << minor << " rev = " << rev << endl;
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // glfw window creation
    // glfw创建窗口
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", nullptr, nullptr);
    if (window == nullptr)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    // 为当前window设置上下文，每个线程只能设置一个，并且线程之间共用时，需要将当前线程设置为 non-current
    glfwMakeContextCurrent(window);

    // 设置窗口大小的回调函数，当窗口大小改变时，会调用该函数调整串口的大小
    // 注册窗口大小改变回调函数
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // glad 会加载所有openGL函数指针，在调用任何opengl函数之前需要先初始化glad
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }


    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    // 创建一个着色器对象， 返回出着色器的ID
    //  顶点着色器
    int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    // 将着色器源码附加到着色器对象上，然后使用glCompileShader进行编译
    // param1 着色器ID, param2 源码字符串数量
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }

    // fragment shader
    // 片段着色器
    int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // link shaders
    /*
    当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。
    当输出和输入不匹配的时候，你会得到一个连接错误。
     */
    int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    // check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float vertices[] = {
            -0.5f, -0.5f, 0.0f, // left
            0.5f, -0.5f, 0.0f, // right
            0.0f,  0.5f, 0.0f  // top
    };

    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    /* 要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用 */
    /* // ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
    // 1. 绑定VAO */
    glBindVertexArray(VAO);
    // 2. 把顶点数组复制到缓冲中供OpenGL使用
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    // 把之前定义的顶点，复制到缓冲的内存中去
    /*
    GL_STATIC_DRAW ：数据不会或几乎不会改变。
    GL_DYNAMIC_DRAW：数据会被改变很多。
    GL_STREAM_DRAW ：数据每次绘制时都会改变。 */
    /*
    三角形的位置数据不会改变，每次渲染调用时都保持原样，所以它的使用类型最好是GL_STATIC_DRAW。
    如果，比如说一个缓冲中的数据将频繁被改变，那么使用的类型就是GL_DYNAMIC_DRAW或GL_STREAM_DRAW，
    这样就能确保显卡把数据放在能够高速写入的内存部分。 */
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    /*
    位置数据被储存为32位（4字节）浮点值。
    每个位置包含3个这样的值。
    在这3个值之间没有空隙（或其他值）。这几个值在数组中紧密排列(Tightly Packed)。
    数据中第一个值在缓冲开始的位置 */
    //  告诉GPU数据怎样取
    /*
    第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用layout(location = 0)
       定义了position顶点属性的位置值(Location)吗？它可以把顶点属性的位置值设置为0。
       因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入0。
    第二个参数指定顶点属性的大小。顶点属性是一个vec3，它由3个值组成，所以大小是3。
    第三个参数指定数据的类型，这里是GL_FLOAT(GLSL中vec*都是由浮点数值组成的)。
    下个参数定义我们是否希望数据被标准化(Normalize)。如果我们设置为GL_TRUE，
       所有数据都会被映射到0（对于有符号型signed数据是-1）到1之间。
       我们把它设置为GL_FALSE。
    第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。
      由于下个组位置数据在3个float之后，我们把步长设置为3 * sizeof(float)。
      要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）
      我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。
      一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，
      我们在后面会看到更多的例子（译注: 这个参数的意思简单说
      就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节）。
    最后一个参数的类型是void*，所以需要我们进行这个奇怪的强制类型转换。
      它表示位置数据在缓冲中起始位置的偏移量(Offset)。由于位置数据在数组的开头，
      所以这里是0。我们会在后面详细解释这个参数。 */
    //   设置顶点属性指针
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    /*
    现在我们已经定义了OpenGL该如何解释顶点数据，
    我们现在应该使用glEnableVertexAttribArray，
    以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。 */
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer 
    //registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // You can unbind the VAO afterwards so other 
    // VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways 
    // so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0);


    // uncomment this call to draw in wireframe polygons.
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    /*
    就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的VBO的顶点数组对象。
    一般当你打算绘制多个物体时，你首先要生成/配置所有的VAO（和必须的VBO及属性指针)，然后储存它们供后面使用。
    当我们打算绘制物体的时候就拿出相应的VAO，绑定它，绘制完物体后，再解绑VAO。
     */
    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        // input
        // -----
        processInput(window);

        // render
        // ------
        //  北背景
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // draw our first triangle
        // 2. 当我们渲染一个物体时要使用着色器程序
        glUseProgram(shaderProgram);
         // seeing as we only have a single 
        // VAO there's no need to bind it every time, 
        // but we'll do so to keep things a bit more organized
        glBindVertexArray(VAO);
        // 3. 绘制物体
        glDrawArrays(GL_TRIANGLES, 0, 3);
        
        // glBindVertexArray(0); // no need to unbind it every time
        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 正确的释放之前分配的所有资源
    glfwTerminate();
    return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
    // 用户按下 esc键，就设置退出串口为真
    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // opengl渲染串口大小，每次调整窗口
    cout << "view port call back" << endl;
    //
    glViewport(0, 0, width, height);
}

如果没有出问题，你将得到下面这幅三角形绘制的图：



如果顺利得到这副图，那么恭喜你，你已经学完了opengl的入门，也学完了opengl的难点，能够掌握三角形的绘制以及原理，后面的学习将会简单很多
github源码仓库
opengl环境准备
opengl编程从入门到精通-hello,window

题目很简单，但是会容易输出格式错误。。。。比如说，两个三角形之间有空行，最后的三角形下面没有。讨论区的哥们真好，指出了常见的错误。



#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<cstdio>
using namespace std;
int main()
{
	char s;
	int n;
	bool flag = false;
	while(cin>>s>>n)
	{
		if(s=='@')break;
		if(flag)cout<<endl;//三角形之间有一行空行
		else
		{
			flag = true;
		}
		for(int i=0;i<n-1;i++)
		{
			for(int k=n-i-2;k>=0;k--)
			cout<<" ";
			if(i==0)cout<<s;
			else
			{
				cout<<s;
				for(int j=0;j<2*i-1;j++)
				cout<<" ";
				cout<<s;
			}
			
			cout<<endl;
		}
		for(int i=0;i<2*n-1;i++)
		cout<<s;
		cout<<endl;
	}
	return 0;
}

 

我们知道三角形外接圆的圆心为中垂线的交点，三角形内切圆的圆心为角平分线的交点。
基于上述理论，下面我们分别画出三角形的外接圆和内切圆
一、画外接圆
1.画三角形
在GeoGebra中画三角形需要用到多边形工具，在绘图区任意点击三点，要封闭图形的时候再点一下起点。对于三角形，画完三个点之后，在点一下最初画的点。如图。

2.画垂直平分线
在GeoGebra中，画垂直平分线有现成的工具，点击垂线的三角形箭头，选择中垂线。

依次点击AB两点，画出中垂线（也叫垂直平分线）

同理，点击AC两点，画出另一条中垂线

3.标记交点，画圆
标记交点要用到点工具里面的交点工具


点击两条中垂线的交点进行标记，鼠标移动到交点附近时，两条直线会变粗显示，这时候就可以点击了

最后我们使用圆工具来画圆
点击交点和三角形ABC中的任意一点，我们就可以画出外接圆了

二、画内切圆
内切圆有很多步骤和画外接圆一样，这里就不重复了
需要用到的工具是线工具里的角平分线工具和垂线工具，画完两条角平分线之后取交点，然后过交点画垂线，再取交点。这样圆心和切点就确定好了


效果如图

三、隐藏线段和标签
有时候，我们需要将不需要的线段隐藏掉，我们可以对某个对象点击右键，里面有显示对象和显示标签，都点一下就隐藏了