【LearnOpenGL学习笔记】——06.坐标系统

已于 2022-04-04 16:24:36 修改
阅读量584 收藏
点赞数 1
文章标签： 经验分享
于 2022-04-04 16:13:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45974407/article/details/123953295
版权

文章目录

1，坐标系统

标准化设备坐标(Normalized Device Coordinate, NDC)：顶点着色器输出
坐标变换过程：模型空间——世界空间——观察空间(右手坐标系)——裁剪空间——屏幕空间
变换过程使用的矩阵（MVP矩阵）：模型、观察、投影

2.变换过程

（1）模型空间到世界空间：模型矩阵
（2）世界空间到观察空间：观察矩阵
（3）观察空间到裁剪空间：投影矩阵，这个步骤将在先前指定范围内的坐标变换为标准化设备坐标的范围(-1.0, 1.0），范围外的坐标会被裁剪。如果只是图元(Primitive)，例如三角形，的一部分超出了裁剪体积(Clipping Volume)，则OpenGL会重新构建这个三角形为一个或多个三角形让其能够适合这个裁剪范围。

投影矩阵分为两种——投影矩阵学习资料
①正交投影矩阵：近平面 = 远平面
glm::ortho(0.0f, 800.0f, 0.0f, 600.0f, 0.1f, 100.0f)——形参：左，右，底，顶，近平面，远平面
②透视投影矩阵：利用w分量，距离越远w越大，根据透视除法，远程坐标越小
glm::mat4 proj = glm::perspective(glm::radians(45.0f), (float)width/(float)height, 0.1f, 100.0f)——形参：视野，宽高比，近平面，远平面
当把透视矩阵的 near 值(近平面位置)设置太大时（如10.0f），OpenGL会将靠近摄像机的坐标（在0.0f和10.0f之间）都裁剪掉，这会导致一个你在游戏中很熟悉的视觉效果：在太过靠近一个物体的时候你的视线会直接穿过去。

（4）裁剪空间中：透视除法，x、y、z分量除以w分量，将4D坐标转化为3D坐标

3.矩阵组合

V(clip)=M(projection)⋅M(view)⋅M(model)⋅V(local)

顶点着色器的输出要求所有的顶点都在裁剪空间内，这正是我们刚才使用变换矩阵所做的。OpenGL然后对裁剪坐标执行透视除法从而将它们变换到标准化设备坐标。OpenGL会使用glViewPort内部的参数来将标准化设备坐标映射到屏幕坐标。这个过程称为视口变换。

4.应用

参考代码：

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <stb_image.h>

#include <iostream>
#include <filesystem>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

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;

float mixValue = 0.2f;

//GLSL(OpenGL Shader Language)
const char* vertexShaderSource =
"#version 330 core\n" //OpenGL版本与模式设置
"layout (location = 0) in vec3 aPos;\n" //定义顶点属性的位置值
"layout (location = 2) in vec2 aTexCoord;\n"//
"out vec2 TexCoord;\n"

"uniform mat4 model;\n"
"uniform mat4 view;\n"
"uniform mat4 projection;\n"

"void main()\n"
"{\n"
"gl_Position = projection * view * model * vec4(aPos, 1.0);\n" //进行顶点变换后设置位置
"TexCoord = vec2(aTexCoord.x,aTexCoord.y);\n"
"}\0";

//Fragment GLSL
const char* fragmentShaderSource =
"#version 330 core\n"
"out vec4 FragColor;\n"//传出的颜色值
"in vec2 TexCoord;\n"
"uniform sampler2D texture1;\n"
"uniform sampler2D texture2;\n"//第二个纹理

"uniform float mixValue;\n"
"void main()\n"
"{\n"
//"FragColor = texture(texture1,TexCoord)*vec4(ourColor,1.0f);\n"//用从顶点着色器输入的值设置要输出的颜色值
"   FragColor = mix(texture(texture1,TexCoord),texture(texture2,TexCoord),mixValue);\n"
"}\0";

int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL05", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    //shader program
    // ---------------------------
    //vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);//顶点着色器对象创建
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);//GLSL设置
    glCompileShader(vertexShader);//
    //编译检测
    int success;
    char infolog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);//success存储编译结果
    if (!success) {
        glGetShaderInfoLog(vertexShader, 512, NULL, infolog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infolog << std::endl;
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    //编译检测
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infolog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infolog << std::endl;
    }
    //着色器链接
    unsigned int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    //编译检测
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infolog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infolog << std::endl;
    }
    //delete shader
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

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

    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
    -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
     0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
     0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    };

    glm::vec3 cubePositions[] = {
  glm::vec3(0.0f,  0.0f,  0.0f),
  glm::vec3(2.0f,  5.0f, -15.0f),
  glm::vec3(-1.5f, -2.2f, -2.5f),
  glm::vec3(-3.8f, -2.0f, -12.3f),
  glm::vec3(2.4f, -0.4f, -3.5f),
  glm::vec3(-1.7f,  3.0f, -7.5f),
  glm::vec3(1.3f, -2.0f, -2.5f),
  glm::vec3(1.5f,  2.0f, -2.5f),
  glm::vec3(1.5f,  0.2f, -1.5f),
  glm::vec3(-1.3f,  1.0f, -1.5f)
    };

    unsigned int indices[] = {
        0, 1, 3, // first triangle
        1, 2, 3  // second triangle
    };
    unsigned int VBO, VAO, EBO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // position attribute
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // texture coord attribute
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(2);


    // load and create a texture 
    // -------------------------
    unsigned int texture1, texture2;
    glGenTextures(1, &texture1);
    glBindTexture(GL_TEXTURE_2D, texture1); // all upcoming GL_TEXTURE_2D operations now have effect on this texture object
    // set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	// set texture wrapping to GL_REPEAT (default wrapping method)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // load image, create texture and generate mipmaps
    int width, height, nrChannels;
    stbi_set_flip_vertically_on_load(true);
    // The FileSystem::getPath(...) is part of the GitHub repository so we can find files on any IDE/platform; replace it with your own image path.
    const std::string filename = "F:/DeskTop/container.jpg";
    unsigned char* data = stbi_load(filename.c_str(), &width, &height, &nrChannels, 0);
    if (data)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        std::cout << "Failed to load texture" << std::endl;
    }
    stbi_image_free(data);
    //texture2
    glGenTextures(1, &texture2);
    glBindTexture(GL_TEXTURE_2D, texture2); // all upcoming GL_TEXTURE_2D operations now have effect on this texture object
    // set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	// set texture wrapping to GL_REPEAT (default wrapping method)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // load image, create texture and generate mipmaps
    // The FileSystem::getPath(...) is part of the GitHub repository so we can find files on any IDE/platform; replace it with your own image path.
    const std::string filename1 = "F:/DeskTop/1.jpg";
    unsigned char* data1 = stbi_load(filename1.c_str(), &width, &height, &nrChannels, 0);
    if (data1)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data1);
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        std::cout << "Failed to load texture1" << std::endl;
    }
    stbi_image_free(data1);

    glUseProgram(shaderProgram);
    glUniform1i(glGetUniformLocation(shaderProgram, "texture1"), 0);
    glUniform1i(glGetUniformLocation(shaderProgram, "texture2"), 1);

    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        // input
        // -----
        processInput(window);

        // render
        // ------
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        //开启深度缓冲
        glEnable(GL_DEPTH_TEST);

        // bind Texture
        glActiveTexture(GL_TEXTURE0);//激活
        glBindTexture(GL_TEXTURE_2D, texture1);
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, texture2);

        
        //glm::mat4 transform = glm::mat4(1.0f);//
        transform = glm::rotate(transform, (float)glfwGetTime(), glm::vec3(0.0f, 0.0f, 1.0f));
        //transform = glm::translate(transform, glm::vec3(0.5, -0.5, 0.0f));//平移
        //transform = glm::rotate(transform, (float)glfwGetTime(), glm::vec3(0.0f, 0.0f, 1.0f));//旋转
        //transform = glm::scale(transform, glm::vec3(0.5f, 0.5f, 1.0f));//缩放


        // activate shader
        glUseProgram(shaderProgram);

        //create transformations
        //glm::mat4 model = glm::mat4(1.0f);
        glm::mat4 view = glm::mat4(1.0f);
        glm::mat4 projection = glm::mat4(1.0f);
        //model = glm::rotate(model, (float)glfwGetTime()*glm::radians(-55.0f), glm::vec3(1.0f, 1.0f, 1.0f));
        view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
        projection = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);

        glUniform1f(glGetUniformLocation(shaderProgram, "mixValue"), mixValue);
        glm::value_ptr() :获取矩阵各个方向的值;
        //glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "transform"),1,GL_FALSE, glm::value_ptr(transform));//获取到地址后传入值
        //glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1, GL_FALSE, glm::value_ptr(model));
        glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "view"), 1, GL_FALSE, &view[0][0]);
        glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "projection"), 1, GL_FALSE, &projection[0][0]);


        glBindVertexArray(VAO);
        //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        for (unsigned int i = 0; i < 10; i++)
        {
            glm::mat4 model = glm::mat4(1.0f);
            model = glm::translate(model, cubePositions[i]);
            float angle = 20.0f * i;
            model = glm::rotate(model, (float)glfwGetTime() * glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));
            glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1, GL_FALSE, glm::value_ptr(model));

            glDrawArrays(GL_TRIANGLES, 0, 36);
        }

        //绘制立体图形
        //glDrawArrays(GL_TRIANGLES, 0, 36);

        //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        // 
        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    glfwTerminate();
    return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
    {
        mixValue += 0.001f;
        if (mixValue >= 1.0f)
            mixValue = 1.0f;
    }

    if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
    {
        mixValue -= 0.001f;
        if (mixValue <= 0.0f)
            mixValue = 0.0f;
    }
}

// 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)
{
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays.
    glViewport(0, 0, width, height);
}

（1）3D平面
在这里插入图片描述
（2）立方体旋转
在这里插入图片描述
（3）更多立方体
在这里插入图片描述

Wascofe
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LearnOpenGL学习笔记(六):坐标系统
qq_32925781的博客
10-02 267
简介LearnOpenGL学习笔记(六)1.概述2.代码和运行结果 LearnOpenGL学习笔记(六) 1.概述 在OpenGL中，对我们来说比较重要的总共有5个不同的坐标系统： 局部空间(Local Space，或者称为物体空间(Object Space)) 世界空间(World Space) 观察空间(View Space，或者称为视觉空间(Eye Space)) 裁剪空间(Clip Sp...
学习笔记——sql.zip
06-08
"学习笔记——sql.zip"这个压缩包文件很可能包含了关于SQL的学习资料，如教程、笔记、示例代码等，旨在帮助用户掌握SQL的基本概念、语法和高级特性。 首先，SQL的基础知识包括数据类型，如整型（INT）、浮点型...
LearningOpenGL总结归纳之坐标系统篇
weixin_44431550的博客
04-13 442
坐标系统 五个重要的坐标系统 局部空间（Local Space） 世界空间（World Space） 观察空间（View Space） 裁剪空间（Clip Space） 屏幕空间（Screen Space） 为了将坐标从一个坐标系变换到另一个坐标系，需要经过MVP变换。 局部空间 顶点坐标起始于局部空间，在这里它被称为局部坐标，取个参照物就很好理解概念，局部坐标可以理解为相对于其他物体的坐标，它与世界坐标能够很好的区分开，世界空间坐标就是物体相对于整个场景的坐标。 世界空间 在某个游戏场景中，会存在非常
LearnOpenGL | 坐标系统
【黑键】
09-22 287
LearnOpenGL | 坐标系统 https://learnopengl-cn.github.io/01 Getting started/08 Coordinate Systems/ 总共有5个不同的坐标系统: 局部空间(Local Space，或者称为物体空间(Object Space)) 世界空间(World Space) 观察空间(View Space，或者称为视觉空间(Eye S...
learnOpenGL_06_坐标系统
qq_38526811的博客
08-16 85
1、 OpenGL中可见的所有顶点都为标准化设备坐标，每个顶点的x,y,z都应该在-1.0到1.0之间，超出这个坐标范围的顶点都将不可见。通常会自己设定一个坐标的范围，之后再在顶点着色器中将这些坐标变换为标准化设备坐标。然后将这些标准化设备坐标传入光栅器(Rasterizer)，将它们变换为屏幕上的二维坐标或像素。 2、 将坐标变换为标准化设备坐标，接着再转化为屏幕坐标的过程通常是分步进行的。顶点在最终转化为屏幕坐标之前还会被变换到多个坐标系统(Coordinate System)。将物体的坐标变换到几个过
OpenGL学习 （六）坐标系统
xhh22900的博客
06-08 264
OpenGL学习 （六）坐标系统 参考官方文档https://learnopengl-cn.github.io/ 将坐标变换为标准化设备坐标，然后转换为屏幕坐标的过程是分布进行的。有5个比较重要的坐标系统： 局部坐标 世界坐标 观察坐标 裁剪坐标 屏幕坐标 坐标变换的过程中会用到几个变换矩阵：模型、观察、投影矩阵。 现在我们可以进行3D绘图了。 顶点着色器shader.vs #version 330 core layout(location=0) in vec3 aPos; layout(locatio
读书笔记——AGoodManIsHardToFind.pdf
12-07
读书笔记——AGoodManIsHardToFind.pdf 读书笔记——AGoodManIsHardToFind.pdf 是一篇关于美国南方女作家 Flannery O'Connor 的读书笔记。该笔记主要讨论了 O'Connor 的小说《好人难寻》（A Good Man Is Hard to ...
MySQL笔记——笔记.md
10-02
MySQL笔记
网络运维笔记——T221.docx
07-11
《网络运维笔记——T221》主要涵盖了网络运维中的关键知识点，包括TCP与UDP报文首部的解析、访问控制列表（ACL）的工作原理与配置，以及网络地址转换（NAT）的操作流程和相关概念。以下是这些主题的详细解释： 一、...
魅力数学简笔记——海岩.pdf
09-27
笔记中强调了理解和掌握这些思想的重要性，指出只要能读懂每句话，数学学习的问题就能迎刃而解。 首先，笔记详细阐述了**极限思想**，这是数学的基础，用于在函数和数列中解决问题。极限思想通过研究函数在某一点...
LearnOpenGL-入门-8.坐标系统
qq_34060370的博客
02-28 776
局部坐标是对象相对于局部原点的坐标，也是物体起始的坐标局部坐标通过Model矩阵变换为世界空间坐标，这些坐标相对于世界的全局原点，它们会和其它物体一起相对于世界的原点进行摆放。观察空间坐标，通过view矩阵将世界空间转换到观察空间，使得每个坐标都是从摄像机或者说观察者的角度进行观察的。裁剪坐标，通过投影矩阵从观察空间到裁剪空间，裁剪坐标会被处理（透视除法）至-1.0到1.0的范围内，并判断哪些顶点将会出现在屏幕上。视口变换。
LearnOpenGL学习笔记—入门06：Transformations
清清！的博客
07-24 2884
LearnOpenGL学习笔记—入门06：变换0 前言1 0 前言 本节笔记对应的内容 变换 在入门01中我们配置好了环境 在入门02中我们可以检测输入并出现一个有颜色的窗口 在入门03中我们初步学习了图形渲染管线，尝试用不同方法画出了三角形和四边形 在入门04（上）中我们学习了shader和GLSL的相关知识，并给图形加上了变换的颜色以及彩色。 在入门04（下）中我们建立自己的shader类，并能够从外部读取shader的内容。 在入门05中我们了解了有关材质的内容 尽管我们现在已经知道了如何创建一个物体
跟着LearnOpenGL学习7--坐标系统
最新发布
贝勒里恩的博客
06-07 683
OpenGL希望在每次顶点着色器运行后，我们可见的所有顶点都为标准化设备坐标(Normalized Device Coordinate, NDC)。也就是说，每个顶点的x，y，z坐标都应该在-1.0到1.0之间，超出这个坐标范围的顶点都将不可见。我们通常会自己设定一个坐标的范围，之后再在顶点着色器中将这些坐标变换为标准化设备坐标。然后将这些标准化设备坐标传入光栅器(Rasterizer)，将它们变换为屏幕上的二维坐标或像素。
Learnopengl(6)坐标系统[转]
baidu_41388533的博客
11-28 217
【代码】Learnopengl(6)坐标系统[转]
LearnOpenGL学习笔记—入门06 附：关于四元数
清清！的博客
07-24 2313
关于四元数 避免万向节死锁的真正解决方案是使用四元数(Quaternion) 本节关于四元数的理解以及它对三维旋转的作用，主要对3Blue1Brown的视频进行了描述，可以从这两个视频找到它：四元数的可视化，四元数和三维转动 1 四元数的可视化 这个视频中，3B1B给我们建立了直观印象，看四元数对四维空间都干了什么，以此来可以更好理解四元数的公式 视频中分了以下几个主题展开 1.怎样到一个只能理解一维的人来理解复数 2.向只能理解二维的人描述三维旋转 3.在三维的约束下，表现四元数在干什么 1.1 从一
LearnOpenGL学习笔记—入门：复习与总结
清清！的博客
07-27 1125
LearnOpenGL学习笔记—入门08：Camera 在入门01中我们配置好了环境中我们配置好了环境 在入门02中我们可以检测输入并出现一个有颜色的窗口 在入门03中我们初步学习了图形渲染管线，尝试用不同方法画出了三角形和四边形 在入门04（上）中我们学习了shader和GLSL的相关知识，并给图形加上了变换的颜色以及彩色。 在入门04（下）中我们建立自己的shader类，并能够从外部读取shader的内容。 在入门05中我们了解了有关材质的内容 在入门06中，我们尝试用旋转矩阵以及四元数的方法组成变换矩
【Learn OpenGL 学习笔记】二 · 坐标与摄像机
就一笔记本儿
11-27 535
学习笔记
OpenGL 坐标系统概述 (二)
TanJiaXiang的博客
12-11 624
OpenGL 坐标系统概述 1. OpenGL坐标系统概述   OpenGL希望每次顶点着色后，我们的可见顶点都为标准化设备坐标（Normalized Device Coordinate,NDC）。也就是说每个顶点的x,y,z都应该在−1到1之间，超出这个范围的顶点将是不可见的。 通常情况下我们会自己设定一个坐标范围，之后再在顶点着色器中将这些坐标变换为表转化设备坐标。然后这些标化设备坐标传入光栅器（Rasterizer）,将它们变换为屏幕上的二维坐标和像素。 将坐标变换为标准化设备坐
柔性matlab机械臂运动空间代码,中正平和的机器人学笔记——2. 机械臂逆运动学（附MATAB代码）...
06-06
以下是一个简单的基于MATLAB的机械臂逆运动学示例代码： ```matlab % 定义机械臂参数 L1 = 1; % 第一段臂长 L2 = 1; % 第二段臂长 % 输入末端执行器的坐标 x = input('请输入末端执行器的x坐标：'); y = input('请输入末端执行器的y坐标：'); % 计算逆运动学 theta2 = acos((x^2 + y^2 - L1^2 - L2^2)/(2*L1*L2)); theta1 = atan2(y,x) - atan2((L2*sin(theta2)),(L1+L2*cos(theta2))); % 将弧度转换为角度 theta1 = theta1 * 180/pi; theta2 = theta2 * 180/pi; % 输出关节角度 fprintf('第一关节角度为：%f°\n', theta1); fprintf('第二关节角度为：%f°\n', theta2); ``` 这是一个简单的二自由度机械臂逆运动学示例。输入末端执行器的x和y坐标，程序将计算出第一和第二关节的角度。需要注意的是，此代码仅适用于特定的机械臂结构和工作区域。如果需要适用于其他机械臂，请根据具体情况进行修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值