精华内容
下载资源
问答
  • opengl es 坐标系

    2017-05-11 20:27:19
    opengl es 坐标系坐标系OpenGL中存在6种坐标系 1. Object or model coordinates 2. World coordinates 3. Eye (or Camera) coordinates 4. Clip coordinates 5. Normalized device coordinates 6. Window ...

    opengl es 坐标系

    坐标系:
    OpenGL中存在6种坐标系
    1. Object or model coordinates
    2. World coordinates
    3. Eye (or Camera) coordinates
    4. Clip coordinates
    5. Normalized device coordinates
    6. Window (or screen) coordinates

    World coordinates:
    以屏幕中心为原点(0, 0, 0),且是始终不变。
    面对屏幕, 从左到右,x递增, 从下到上,y递增, 从远到近,z递增
    (也可理解为右边是x正轴,上面是y正轴,屏幕指向外的为z正轴, 笛卡尔坐标系)。
    窗口范围按此单位恰好是(-1,-1)到(1,1),即屏幕左下角坐标为(-1,-1),右上角
    坐标为(1,1))

    Window (or screen) coordinates:
    应用在设备屏幕上的坐标系。也就是图形最终绘制的地方。左上角为原点,向右为X正方向,向下为y的正方向,大小由屏幕像素大小决定

    初始化时,object coordinates、world coordinates、camera coordinates三者坐标重合在原点
    从object coordainates到world coordinates再到camera coordinate的变换,在OPENGL中统一称为model-view转换

    OpenGL中提供了glTranslate*/glRotate*/glScale*三条坐标变换命令,利用OpenGL的矩阵运算命令,则可以实现任意复杂的坐标变换。
    OpenGL中有一个坐标变换矩阵栈(ModelView),栈顶就是当前坐标变换矩阵,进入OpenGL管道的每个坐标(齐次坐标)都会先乘上这个矩阵,结果才是对应点在场景中的世界坐标。OpenGL中的坐标变换都是通过矩阵运算完成的

    纹理坐标
    纹理实际上是一个二维数组,它的元素是一些颜色值,单个的颜色值被称为纹理元素(texture elements)或纹理像素(texture pixel)。每一个纹理像素在纹理中都有一个唯一的地址。这个地址可以被认为是一个列(column)和行(row)的值,它们分别由U和V(或者S和T)来表示。
    纹理坐标位于纹理空间中。也就是说,它们和纹理中的(0,0)位置相对应。当我们将一个纹理应用于一个图元时,它的纹理像素地址必须要映射到对象坐标系中。然后再被平移到屏幕坐标系或像素位置上(即纹理坐标决定了纹理图像中的纹理单元将分配给那个顶点)

    纹理映射(Texture Mapping),又称纹理贴图,是将纹理空间中的纹理像素映射到屏幕空间中的像素的过程。简单来说,就是把一幅图像贴到三维物体的表面上来增强真实感,
    物体表面上每一点的纹理像素都能在纹理映射中找到。

    顶点信息一般包括:
    (1)三维坐标信息; (2)三维法向量信息;(3)颜色信息或二维贴图坐标信息(即纹理坐标信息);
    (复杂物体的坐标通常通过特定的软件绘制生成顶点信息文件,然后进行解读);

    openGL的图形都是由很多顶点,按照一定的规则链接起来构成的图形。
    那么纹理坐标的4个坐标点,映射到顶点上。openGL就会把这个纹理应用到4个顶点构成的图形上。

    普通坐标(Ordinary Coordinate)和齐次坐标(Homogeneous Coordinate)之间进行转换:
    (齐次坐标更易用于进行仿射(线性)几何变换)
    (1)从普通坐标转换成齐次坐标时
    如果(x,y,z)是个点,则变为(x,y,z,1);
    如果(x,y,z)是个向量,则变为(x,y,z,0)
    (2)从齐次坐标转换成普通坐标时
    如果是(x,y,z,1),则知道它是个点,变成(x,y,z);
    如果是(x,y,z,0),则知道它是个向量,仍然变成(x,y,z)

    矩阵栈切换:
    glMatrixMode(GL_MODELVIEW /GL_PROJECTION/GL_TEXTURE/GL_COLOR),执行后参数所指矩阵栈就成为当前矩阵栈,以后的矩阵栈操纵命令将作用于它。
    纹理矩阵:
    纹理坐标也可以通过纹理矩阵来进行变换。纹理矩阵的工作方式与投影矩阵,模型视图矩阵类似。
    通过glMatrixMode(GL_TEXTURE):来开启纹理矩阵模式,在此函数调用后面的矩阵变换将被应用于纹理坐标。
    纹理坐标可以进行移动、缩放、旋转。纹理矩阵的栈最多只能容纳两个纹理矩阵

    展开全文
  • OpenGL 坐标系 OpenGL是一个右手坐标系。就是正x轴在你的右手边,正y轴朝上,而正z轴是朝向后方的。取值是在【-1,1】之间。原点(0,0)在屏幕的中心。 OpenGL世界坐标系 参看下面的右手法则 OpenGL世界坐标系 纹理...

    OpenGL 坐标系

    OpenGL是一个右手坐标系。就是正x轴在你的右手边,正y轴朝上,而正z轴是朝向后方的。取值是在【-1,1】之间。原点(0,0)在屏幕的中心。

    OpenGL世界坐标系

    参看下面的右手法则

    OpenGL世界坐标系

    纹理坐标系

    纹理坐标系的取值在【0,1】之间。原点(0,0)在屏幕左下角。

    转载于:https://juejin.im/post/5a7586c3f265da4e732ea153

    展开全文
  • OPENGL常用坐标系介绍

    2017-09-19 17:30:27
    世界坐标系:这是最大的坐标系,这个坐标系描述的是其它坐标系所需要的参考框架,可以理解为其中的物理定律都适用于其子坐标系。  物体坐标系:在世界坐标系中的,或者是某些物体坐标系中的坐标系,其实很有用,...

      世界坐标系:这是最大的坐标系,这个坐标系描述的是其它坐标系所需要的参考框架,可以理解为其中的物理定律都适用于其子坐标系。

      物体坐标系:在世界坐标系中的,或者是某些物体坐标系中的坐标系,其实很有用,这样物体坐标系的个体就可以只考虑在物体坐标系中的变化,不用担心对世界坐标系的位置变化。

    左手系和右手系:(取自徐明亮的《OPENGL游戏编程》非常推荐的书)






    展开全文
  • //opengl坐标系和世界坐标系相同,都是以屏幕左下角为原点,向右为x轴的增加方向,向上为y轴的增加方向 //这里的世界指的是游戏世界 //屏幕坐标系是以左上角为原点,是我们熟悉的 //本地坐标系也叫节点坐标...
  • OpenGL坐标系1

    千次阅读 2019-11-19 19:43:09
    此项目为Qt5所写,用到的是可编程管线的现代OpenGL,通过继承Qt中...其实实现这个坐标系在老版本的OpenGL(freeglut,glut)中是很简单的,只需几行代码,但是在可编程管线中,由于要编写着色器,复杂程度就稍微高了...

    此项目为Qt5所写,用到的是可编程管线的现代OpenGL,通过继承Qt中的QOpenGLWidget和QOpenGLExtraFunctions实现。只是一个最简单的坐标系,三条不同颜色的直线分别代表x, y, z轴,整体效果如下:

     

    其实实现这个坐标系在老版本的OpenGL(freeglut,glut)中是很简单的,只需几行代码,但是在可编程管线中,由于要编写着色器,复杂程度就稍微高了一点。项目整体目录如下:

     

    Coordinate.h

    #include <QOpenGLExtraFunctions>
    
    class Coordinate : protected QOpenGLExtraFunctions
    {
    public:
        Coordinate();
        ~Coordinate();
    
        void init();
        void drawX();
        void drawY();
        void drawZ();
    
    private:
        GLuint VBOX = 0;
        GLuint VBOY = 0;
        GLuint VBOZ = 0;
    };

    Coordinate.cpp

    #include "coordinate.h"
    
    Coordinate::Coordinate()
    {
        this->initializeOpenGLFunctions();
    }
    
    Coordinate::~Coordinate()
    {
        if(VBOX || VBOY || VBOZ)
        {
            glDeleteBuffers(1, &VBOX);
            glDeleteBuffers(1, &VBOY);
            glDeleteBuffers(1, &VBOZ);
        }
    }
    
    void Coordinate::init()
    {
        float verticesX[] = {
            0.0f, 0.0f, 0.0f,
            1.0f, 0.0f, 0.0f,
        };
    
        float verticesY[] = {
            0.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f,
        };
    
        float verticesZ[] = {
            0.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f
        };
    
        glGenBuffers(1, &VBOX);
        glBindBuffer(GL_ARRAY_BUFFER, VBOX);
        glBufferData(GL_ARRAY_BUFFER, sizeof(verticesX), verticesX, GL_STATIC_DRAW);
    
        glGenBuffers(1, &VBOY);
        glBindBuffer(GL_ARRAY_BUFFER, VBOY);
        glBufferData(GL_ARRAY_BUFFER, sizeof(verticesY), verticesY, GL_STATIC_DRAW);
    
        glGenBuffers(1, &VBOZ);
        glBindBuffer(GL_ARRAY_BUFFER, VBOZ);
        glBufferData(GL_ARRAY_BUFFER, sizeof(verticesZ), verticesZ, GL_STATIC_DRAW);
    }
    
    void Coordinate::drawX()
    {
        glBindBuffer(GL_ARRAY_BUFFER, VBOX);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);
        glDrawArrays(GL_LINES, 0, 2);
    }
    
    void Coordinate::drawY()
    {
        glBindBuffer(GL_ARRAY_BUFFER, VBOY);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);
        glDrawArrays(GL_LINES, 0, 2);
    }
    
    void Coordinate::drawZ()
    {
        glBindBuffer(GL_ARRAY_BUFFER, VBOZ);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);
        glDrawArrays(GL_LINES, 0, 2);
    }
    

     

    Shader.h 

    #include <QDebug>
    #include <QOpenGLShader>
    #include <QOpenGLShaderProgram>
    #include <QString>
    
    class Shader {
    public:
      Shader(const QString& vertexSource, const QString& fragmentSource, const QString& geometrySource = NULL);
    
      ~Shader();
    
      void use(){
        shaderProgram->bind();
      }
    
      void setFloat(const QString& name, const GLfloat& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    
      void setInteger(const QString& name, const GLint& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    
      void setVector2f(const QString& name, const GLfloat& x, const GLfloat& y){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, QVector2D(x, y));
      }
    
      void setVector2f(const QString& name, const QVector2D& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    
      void setVector3f(const QString& name, const GLfloat& x, const GLfloat& y, const GLfloat& z){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, QVector3D(x, y, z));
      }
    
      void setVector3f(const QString& name, const QVector3D& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    
      void setVector4f(const QString& name, const GLfloat& x, const GLfloat& y, const GLfloat& z, const GLfloat& w){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, QVector4D(x, y, z, w));
      }
    
      void setVector4f(const QString& name, const QVector4D& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    
      void setMatrix4f(const QString& name, const QMatrix4x4& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    
      void setBool(const QString& name, const GLboolean& value){
        GLuint loc = shaderProgram->uniformLocation(name);
        shaderProgram->setUniformValue(loc, value);
      }
    private:
        QOpenGLShaderProgram *shaderProgram;
    };

    Shader.cpp

    #include "shader.h"
    
    Shader::Shader(const QString& vertexSource, const QString& fragmentSource, const QString& geometrySource){
        QOpenGLShader vertexShader(QOpenGLShader::Vertex);
        bool success = vertexShader.compileSourceFile(vertexSource);
        if(!success){
            qDebug() << "ERROR::SHADER::VERTEX::COMPILATION_FAILED" << endl;
        }
    
        QOpenGLShader fragmentShader(QOpenGLShader::Fragment);
        success  = fragmentShader.compileSourceFile(fragmentSource);
        if(!success){
            qDebug() << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED" << endl;
        }
    
        QOpenGLShader geometryShader(QOpenGLShader::Geometry);
        if(geometrySource != NULL){
            success  = geometryShader.compileSourceFile(geometrySource);
            if(!success){
                qDebug() << "ERROR::SHADER::GEOMETRY::COMPILATION_FAILED" << endl;
            }
        }
    
        shaderProgram = new QOpenGLShaderProgram();
        shaderProgram->addShader(&vertexShader);
        shaderProgram->addShader(&fragmentShader);
        if(geometrySource != NULL)
            shaderProgram->addShader(&geometryShader);
        success = shaderProgram->link();
        if(!success){
            qDebug() << "ERROR::SHADER::PROGRAM::LINKING_FAILED" << endl;
        }
    }

     

    Widget.h 

    #include <QOpenGLWidget>
    #include <QOpenGLExtraFunctions>
    #include <coordinate.h>
    #include <shader.h>
    
    class Widget : public QOpenGLWidget, protected QOpenGLExtraFunctions
    {
        Q_OBJECT
    
    public:
        explicit Widget(QWidget *parent = 0);
        ~Widget();
    
    protected:
        void initializeGL() override;
        void resizeGL(int w, int h) override;
        void paintGL() override;
    
    private:
        Coordinate *coordinate;
        Shader *shaderX;
        Shader *shaderY;
        Shader *shaderZ;
    };

    Widget.cpp 

    #include "widget.h"
    
    Widget::Widget(QWidget *parent) : QOpenGLWidget(parent)
    {
        this->setWindowTitle("Coordinate");
    }
    
    Widget::~Widget()
    {
        delete shaderX;
        delete shaderY;
        delete shaderZ;
    }
    
    void Widget::initializeGL(){
        this->initializeOpenGLFunctions();
    
        // load shaders
        shaderX = new Shader(":/shaders/CoordinateX.vert",":/shaders/CoordinateX.frag");
        shaderY = new Shader(":/shaders/CoordinateY.vert",":/shaders/CoordinateY.frag");
        shaderZ = new Shader(":/shaders/CoordinateZ.vert",":/shaders/CoordinateZ.frag");
    
        coordinate = new Coordinate();
        coordinate->init();
    
        // set projection and view matrix
        QMatrix4x4 projection, view;
        view.translate(QVector3D(0.0f, -0.5f, -3.0f)); // camera view
        projection.perspective(45.0f, (GLfloat)width() / (GLfloat)height(), 0.1f, 100.0f);
    
        shaderX->use();
        shaderX->setMatrix4f("view", view);
        shaderX->setMatrix4f("projection", projection);
        shaderY->use();
        shaderY->setMatrix4f("view", view);
        shaderY->setMatrix4f("projection", projection);
        shaderZ->use();
        shaderZ->setMatrix4f("view", view);
        shaderZ->setMatrix4f("projection", projection);
    
        glEnable(GL_DEPTH_TEST);
    }
    
    void Widget::resizeGL(int w, int h)
    {
        glViewport(0, 0, w, h);
    }
    
    void Widget::paintGL()
    {
        glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        QMatrix4x4 model;
        model.setToIdentity(); // Initializing, Set the rectangle to an identity matrix
        model.rotate(-45.0f, 0.0f, 1.0f ,0.0f); // rotate coordinate system to aovid blocking z-axis
    
        // draw x,y,z coordinate axis
        shaderX->use();
        shaderX->setMatrix4f("model", model);
        coordinate->drawX();
        shaderY->use();
        shaderY->setMatrix4f("model", model);
        coordinate->drawY();
        shaderZ->use();
        shaderZ->setMatrix4f("model", model);
        coordinate->drawZ();
    }
    

     

    CoordinateX.vert 

    #version 330 core
    layout (location = 0) in vec3 aPos;
    
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    void main(){
        gl_Position = projection * view * model * vec4(aPos, 1.0f);
    }
    

    CoordinateX.frag 

    #version 330 core
    out vec4 FragColor;
    
    void main()
    {
            FragColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
    }
    

    y轴z轴着色器的代码和上面两个是一样的,除了FragColor中改了颜色,pro文件和main.cpp是自动生成的就不放代码了。很简单的一个坐标系,在每个轴末端加上一个小圆锥体效果会更好,有空尝试一下。

     

    在"OpenGL画坐标系2"中增加了轴末端的四棱锥,效果更好,并且重构了代码,链接如下:https://blog.csdn.net/qq_37996632/article/details/103178120

     

    展开全文
  • 而对于三维坐标系,一般有两种习俗,左手坐标系和右手坐标系,它们的重点不是在于 z 轴标注的是哪根,而是三个方向的组合,比如之前的[从零开始计算机图形学]系列一直用左手坐标系,为了作图方便,我把 z 轴指向屏幕...
  • OpenGL坐标系2

    千次阅读 2019-11-21 10:46:52
    此项目为“OpenGL坐标系1”的拓展,1的链接:https://blog.csdn.net/qq_37996632/article/details/103149535 思路:在原有的直线坐标轴上加上一个小的...注意:对比“OpenGL坐标系1”,修改了Coordinate.h,Coo...
  • 1)要分清模型坐标系与世界坐标系,物体的旋转平移变换是以模型坐标系为基础来进行的 2)模型开始加载视图中,此时模型坐标系是与世界坐标系重合的 3)在模型通过平移变换后,其模型坐标系也进行相应的变换,此时...
  • OPENGL改变坐标系

    千次阅读 2017-03-31 10:32:44
    这里只是简单讲了如何改变二维情况下的坐标系范围,代码也详细给出了。
  • OpenGL眼睛坐标系和目标坐标系

    千次阅读 2013-11-27 16:14:14
    其实弄懂坐标变换的关键是理解什么是“眼睛坐标系”(eye coordinate system) 和“目标坐标系”(object coordinate system),以及各个API函数使用的是哪套坐标:是“眼睛坐标”还是“目标坐标”。  所谓“眼睛坐标...
  • OpenGL 世界坐标系

    2017-11-16 20:35:00
    OpenGL中,世界坐标系是以屏幕中心为原点(0, 0, 0),且是始终不变的。你面对屏幕,你的右边是x正轴,上面是y正轴,屏幕指向你的为z正轴。长度单位这样来定:窗口范围按此单位恰好是(-1,-1)到(1,1),即屏幕左下角...
  • OpenGL坐标系和像素坐标系

    千次阅读 2016-05-27 13:06:58
    OpenGL坐标系原点在中心,并且做了归一化处理。就是说xy轴,都是从[-1, 1]之间。而像素坐标系是同样的中心点,右上是正方向,只是没有做归一化处理,是以像素为单位的。那么,归一化的坐标系和像素坐标最大的区别...
  • OpenGL坐标系

    2013-11-27 22:38:55
    一直对OpenGL的坐标系感到困惑,上网找了篇不错的文章,迷雾终于去除了。 以下是转载的原文: openGL使用右手坐标 从左到右,x递增 从下到上,y递增 从远到近,z递增 ...OPENGL坐标系可分为:世界坐
  • OpenGL中物体建立在各自的局部坐标系【模型坐标系】中,然后经过平移旋转变换到【世界坐标系】中,然后根据视角的位置和方向转换到【视角坐标系】中,然后根据投影关系,是正交投影还是透视投影,转换到【投影坐标系...
  • 顶点坐标系 的 起点是 左下点(-1, -1),接下来是(1,-1) , (-1, 1) , (1 , 1) 是一个反Z形状 纹理坐标系 的起点是 左下点 (0, 0),接下来是 (1 , 0) , (0, 1 ), (1, 1)是一个反Z形状 .....
  • OpenGL 坐标系定义

    2012-06-24 16:14:51
    OpenGL 坐标系定义
  • OpenGL 坐标系讲解

    2011-01-11 15:21:00
    OpenGL 坐标系讲解,详细讲解OpenGL的坐标关系,坐标装换
  • opengl坐标系to 2D 变换opengl 中的坐标系以view的中心点为原点。而平面物体在屏幕中显示时以屏幕的左上角为原点。通过opengl 显示2D画面时。如果想要对显示物体进行平移,缩放操作就会涉及到原点不一致的情况:...
  • opengl坐标系

    千次阅读 2013-10-08 11:16:13
    视图模型变换(model-view)就是一个将顶点坐标从世界坐标系变换到视觉坐标系的过程。这里很重要的是对两个坐标系的认识。     世界坐标系也称为全局坐标系。它是一个右手坐标系,可以认为该坐标系是固定不变的,...
  • 详解OpenGL坐标系、投影和几何变换
  • OpenGL坐标系

    千次阅读 2014-08-19 13:00:11
    openGL坐标系- -   openGL使用右手坐标 从左到右,x递增 从下到上,y递增 从远到近,z递增 OPENGL坐标系可分为:世界坐标系和当前绘图坐标系。 世界坐标系以屏幕中心为原点(0, 0, 0)。你面对...
  • 基于OpenGL视点坐标系的平移旋转变换,杨艳英,王哲龙,本文基于OpenGL视点坐标系与世界坐标系的相互对应关系,利用视点变换原理实现对三维图形的平移和旋转。并提出一种新的三维图形旋转
  • openGL坐标系

    2017-08-14 19:30:18
    openGL坐标系
  • opengl 坐标系

    2014-06-22 15:03:12
    OPENGL坐标系可分为:世界坐标系和当前绘图坐标系。 世界坐标系以屏幕中心为原点(0, 0, 0)。你面对屏幕,你的右边是x正轴,上面是y正轴,屏幕指向你的为z正轴。长度单位这样来定: 窗口范围按此单位恰好是(-1,-1...
  • opengl坐标系的理解

    千次阅读 2013-06-08 18:25:33
     一般书上把这几个变换用照相机类比,其实每个变换都是产生着一个 4x4 矩阵,然后与当前矩阵(Current Matrix) 相乘,得到一个坐标变换矩阵,最后把世界坐标系(欧式空间)中的物体变换到屏幕坐标系中。...
  • OpenGL坐标系建立

    千次阅读 2012-12-06 19:26:49
    本文转:...openGL使用右手坐标 从左到右,x递增 从下到上,y递增 从远到近,z递增 --------------------------------------------------------------------------
  • OPENGL 矩阵坐标系变换

    千次阅读 2016-02-02 21:37:26
    主要内容总结文章...所谓的坐标系变换就是调用某个函数后得到的坐标。 关系如下图:(当时小谢给我画的~) 绿色框框内的表示需要自己写代码的~
  • OPENGL屏幕坐标系原点在左下角向上向右增加,D3D屏幕坐标系原点在左上角向下向右增加。 所以glViewPort的从设备坐标系变换到屏幕空间的变换公式为: 使得(-1,-1)到左下角(x0,y0), (1,1)到右上角(x0 + w, y0 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,881
精华内容 7,152
关键字:

opengl自坐标系